InstanceOfJava: Java SE

Java SE

Java Versions, Features and History

Posted by: Instanceofjava Posted date: July 11, 2015 / comment : 0 Java SE

Java Versions, Features and History

Released on 23 January 1996, JDK 1.0 version.
Released on 19 February 1997 JDK 1.1 version.
New features in JDK 1.1
1. JDBC (Java Database Connectivity)
2. Inner Classes
3. Java Beans
4. RMI (Remote Method Invocation)
5. Reflection (introspection only)
Released on 8 December 1998 J2SE 1.2 version.
New features in J2SE 1.2
1. Collections framework.
2. Java String memory map for constants.
3. Just In Time (JIT) compiler.
4. Jar Signer for signing Java ARchive (JAR) files.
5. Policy Tool for granting access to system resources.
6. Java Foundation Classes (JFC) which consists of Swing 1.0, Drag and Drop, and Java 2D class libraries.
7. Java Plug-in
8. Scrollable result sets, BLOB, CLOB, batch update, user-defined types in JDBC.
9. Audio support in Applets.
Released on 8 May 2000 J2SE 1.3 version.
New features in J2SE 1.3
1. Java Sound
2. Jar Indexing
3. A huge list of enhancements in almost all the java area.
Released on 6 February 2002 J2SE 1.4 version.
New features in J2SE 1.4
1. XML Processing
2. Java Print Service
3. Logging API
4. Java Web Start
5. JDBC 3.0 API
6. Assertions
7. Preferences API
8. Chained Exception
9. IPv6 Support
10. Regular Expressions
11. Image I/O API
Released on 30 September 2004 J2SE 1.5 version.
New features in J2SE 1.5
1. Generics
2. Enhanced for Loop
3. Autoboxing/Unboxing
4. Enum
5. Varargs
6. Static Import
7. Metadata (Annotations)
8. Instrumentation
Released on 11 December 2006 J2SE 1.6 version.
New features in J2SE 1.6
1. Scripting Language Support
2. JDBC 4.0 API
3. Java Compiler API
4. Pluggable Annotations
5. Native PKI, Java GSS, Kerberos and LDAP support.
6. Integrated Web Services.
7. Lot more enhancements.
Released on 28 July 2011 J2SE 1.7 version.
New features in J2SE 1.7
1. Strings in switch Statement
2. Type Inference for Generic Instance Creation
3. Multiple Exception Handling
4. Support for Dynamic Languages
5. Try with Resources
6. Java nio Package
7. Binary Literals, underscore in literals
8. Diamond Syntax
9. Automatic null Handling

Released on 18th march 2014 JDK 1.8 version.
New features in JDK 1.8

Default and Static methods in Interface
Lambda Expressions
Optional
Streams
Method References
Data Time API
Nashorn Javascript Engine
Parallel Arrays

Can we overload static methods in java

Posted by: Instanceofjava Posted date: June 28, 2015 / comment : 0 Java SE

Yes. We can overload static methods in java.
Method overriding is not possible but method overloading is possible for static methods.
Before that lets see about method overloading in java.

Method overloading:

Defining multiple methods with same name and with different arguments is known as method overloading.
Multiple methods with same name and different arguments so compile time itself we can tell which method is going to get executed based on method call.
Method overloading also known as compile time polymorphism.

Static methods - method overloading

Its always possibles static method overloading.
Defining multiple static methods with same name and different arguments will possible.
By this we can define multiple main methods in our class with different arguments but only default main method will be called by the JVM remaining methods we need to call explicitly.
Lets see an example java program which explains static method overloading.

class StaticMethodOverloading{
public static void staticMethod(){
System.out.println("staticMethod(): Zero arguments");
}
public static void staticMethod(int a){
System.out.println("staticMethod(int a): one argument");
}
public static void staticMethod(String str, int x){
System.out.println("staticMethod(String str, int x): two arguments");
}
public static void main(String []args){
StaticMethodOverloading.staticMethod();
StaticMethodOverloading.staticMethod(12);
StaticMethodOverloading.staticMethod("Static method overloading",10);
}
}

Output:

staticMethod(): Zero arguments
staticMethod(int a): one argument
staticMethod(String str, int x): two arguments

Java Program to overload main method in java

class mainMethodOverloading{
public static void main(boolean x){
System.out.println("main(boolean x) called ");
}
public static void main(int x){
System.out.println("main(int x) called");
}
public static void main(int a, int b){
System.out.println("main(int a, int b) called");
}
public static void main(String []args){
System.out.println("main(String []args) called ");
mainMethodOverloading.main(true);
mainMethodOverloading.main(10);
mainMethodOverloading.main(37,46);
}
}

Output:

main(String []args) called
main(boolean x) called
main(int x) called
main(int a, int b) called

Can we override static methods in java

Posted by: Instanceofjava Posted date: June 28, 2015 / comment : 0 Core java Interview Questions , Java SE

Exact answer is NO. We can not override static methods.
Before discussing this topic lets see what is static in java.

Static methods in java:

Static means class level if we declare any data or method as static then those data(variables) and methods belongs to that class at class level.
Static variables and static methods belongs to class level.
Static methods are not the part of objects state . Belongs to class
Without using object we can call these static methods.

here the detailed explanation on static methods

Instance methods in java:

Instance methods will be called at run time.
Instance variables and instance methods are object level. variables values may change from one object to another where as static variable values are class level so if we access by using any object and changes that values will effect to all objects means its class level variable.

Lets see about overriding in java.

Method overriding in java:

Defining the super class method in sub class with same signature.
Even though in inheritance all properties of supers class can access in sub class we have an option of overriding super class methods in sub class known as method overriding.
So by this every-time sub-most object method will be called.

Instance methods - Method Overriding

class SuperClassDemo{
public void instanceMethod(){
System.out.println("SuperClassDemo instanceMethodcalled");
}
}

class SubClassDemo extends SuperClassDemo{
public void instanceMethod(){
System.out.println("SubClassDemo instanceMethod called");
}
public static void main(String []args){
SuperClassDemo superObj= new SuperClassDemo();
SuperClassDemo superobj1= new SubClassDem();
SubClassDemo subObj= new SubClassDem();
// here no need to create object to call a static method please note that.
superObj.instanceMethod();
superObj1.instanceMethod();
subObj.instanceMethod();
}
}

Output

SuperClassDemo instanceMethodcalled
SubClassDemo instanceMethodcalled
SubClassDemo instanceMethodcalled

Static methods - method overriding:

Lest an example program on static methods in method overriding concept and then discus about this clearly.

class SuperClassDemo{
public static void staticMethod(){
System.out.println("SuperClassDemo staticMethod called");
}
}

class SubClassDemo extends SuperClassDemo{
public static void staticMethod(){
System.out.println("SubClassDemo staticMethod called");
}
public static void main(String []args){
SuperClassDemo superObj= new SuperClassDemo();
SuperClassDemo superobj1= new SubClassDem();
SubClassDemo subObj= new SubClassDem();
// here no need to create object to call a static method please note that.
superObj.staticMethod();
superObj1.staticMethod();
subObj.staticMethod();
}
}

Output

SuperClassDemo staticMethod called
SuperClassDemo staticMethod called
SubClassDemo staticMethod called

Method Overriding - Method Hiding:

Method overriding : in method overriding we will define super class method in sub class with same signature and these methods will be called at run time based on the object.
Method Hiding: In method hiding even though super class methods are accesible in sub class they are not the part of sub class so the methods and these methods will be called based on the class.
In method Hiding if we define same static method in super class and sub class they are not same they are unique and distinct from the other.

public static void main(String[] args) in Java

Posted by: Instanceofjava Posted date: May 23, 2015 / comment : 4 Concept and Interview Questions , Java SE

main method is a standard method used by JVM to execute any java program(Java SE).
Lets see an example class without main method.

package instanceofjava;
public Demo{
}

This class will compile fine but while executing JVM fails to find the main method in that class
So it will throw an exception: NoSuchMethodError:main

package instanceofjava;
public Demo{
public static void main(String [] args){
}
}

This program will compile and executed. Because at run time JVM calls the main method on that class.

Why main method is public?

To call by JVM from anywhere main method should be public.
If JVM wants to call our method outside of our package then our class method should be public.

package instanceofjava;
public MainDemo{
public static void main(String [] args){
}
}

public static void main(string args) interview Questions

Why main method is static?

To execute main method without creating object then the main method oshould be static so that JVM will call main method by using class name itself.

Why main method return type is void?

main method wont return anything to JVM so its return type is void.

Why the name main?

This is the name which is configured in the JVM.

Why the arguments String[] args?

Command line arguments.
String array variable name args : by the naming conventions they named like that we can write any valid variable name.

Can we write static public void main(String [] args)?

Yes we can define main method like static public void main(String[] args){}
Order of modifiers we can change.

package instanceofjava;
public MainDemo{
static public void main(String [] args){
}
}

What are the possible public static void main(String [] args)method declaration with String[] args?

public static void main(String[] args){ }
public static void main(String []args){ }
public static void main(String args[] ){ }
public static void main(String... args){ }
Instead of args can place valid java identifier.

Can we declared main method with final modifier?

Yes we can define main method with final modifier.

package instanceofjava;
public MainDemo{
public static final void main(String [] args){
}
}

Main method with all possible modifiers:

package instanceofjava;
public MainDemo{
static final synchronized public void main(String [] args){
System.out.println("Main method");
}
}

Output:

Main method

Overloading main method:

We can declare multiple main methods with same name as per overloading concept.
So we can overload main method but every time JVM looks for main method with String[] args method.
Lets see an example program on main method overloading.
main(String[] args) method will be called automatically by JVM.
If we want to call other methods we need to call explicitly.

package instanceofjava;
public MainDemo{
public static void main(String [] args){
System.out.println("Main method String [] args");
}
public static void main(int[] args){
System.out.println("Main method int[] args");
}
}

Output:

Main method String [] args

Main method Inheritance:

Inheritance concept is applicable for main method.
If a sub class not having main method and extending a super class which is having main method.
Then if we execute super class main method will be executed fine.
If we execute sub class which is not having main method also executed fine and super class main method will be called.

package instanceofjava;
public A{
public static void main(String [] args){
System.out.println("Main method of class A");
}
}

Output:

Main method of class A

package instanceofjava;
public B extends A{
}

Output:

Main method of class A

What happen if both super and sub class having main method?

Actually its not overriding concept here. it is a method hiding concept in this scenario regarding with main method.

package instanceofjava;
public A{
public static void main(String [] args){
System.out.println("Main method of class A");
}
}

Output:

Main method of class A

package instanceofjava;
public B extends A{
public static void main(String [] args){
System.out.println("Main method of class B");
}
}

Output:

Main method of class B

Static block in Java

Posted by: Instanceofjava Posted date: May 23, 2015 / comment : 0 concept and program , Java SE

Static variables are class level variables and without instantiating class we can access these variables.

Static int a;

Class loading time itself these variables gets memory
Static methods are the methods with static keyword are class level. without creating the object of the class we can call these static methods.

public static void show(){
}

Now its time to discuss about static blocks.
Static block also known as static initializer
Static blocks are the blocks with static keyword.
Static blocks wont have any name in its prototype.
Static blocks are class level.
Static block will be executed only once.
No return statements.
No arguments.
No this or super keywords supported.

static{
}

What is the need of static block?

Static blocks will be executed at the time of class loading.
So if you want any logic that needs to be executed at the time of class loading that logic need to place inside the static block so that it will be executed at the time of class loading.
To initialize the static variables while class loading itself we need static block.
If we have multiple classes then if you want to see the order of those classes loading then static block needed.

When to use static blocks?

If you want to access static variables before executing the constructor.
If you want to execute your code only once even any number of objects created.
If you want to initialize static constants.

When and where static blocks will be executed?

Static blocks will be executed at the time of class loading by the JVM by creating separate stack frames in java stacks area (Please refer JVM Architecture to know about stacks area).
Static blocks will be executed in the order they defined from top to bottom.

package com.instanceofjava;
class StaticBlockDemo
{
static{
System.out.println("First static block executed");
}
static{
System.out.println("Second static block executed");
}
static{
System.out.println("Third static block executed");
}
}

Output:

First static block executed
Second static block executed
Third static block executed

Order of execution of static block and main method:

package com.instanceofjava;
class StaticBlockDemo
{
public static void main (String[] args) throws java.lang.Exception
{
System.out.println("Main method executed");
}
static{
System.out.println("First static block executed");
}
static{
System.out.println("Second static block executed");
}
static{
System.out.println("Third static block executed");
}
}

Output:

First static block executed
Second static block executed
Third static block executed
Main method executed

Order of execution of Static block and constructor:

package com.instanceofjava;
class StaticBlockDemo
{
StaticBlockDemo(){
System.out.println("Constructor executed");
}
public static void main (String[] args) throws java.lang.Exception
{
System.out.println("Main method executed");
StaticBlockDemo obj = new StaticBlockDemo();
}
static{
System.out.println("First static block executed");
}
static{
System.out.println("Second static block executed");
}
static{
System.out.println("Third static block executed");
}
}

Output:

First static block executed
Second static block executed
Third static block executed
Main method executed
Constructor executed

What is the output of following program:

package com.instanceofjava;
class StaticBlockDemo
{
static int a=getNum();
public static int getNum(){
System.out.println("In method m1()");
return 10;
}
public static void main (String[] args) throws java.lang.Exception
{
System.out.println("Main method executed");
}
static{
System.out.println("First static block executed");
}
static{
System.out.println("Second static block executed");
}
static{
System.out.println("Third static block executed");
}
}

Output:

In method m1()
First static block executed
Second static block executed
Third static block executed
Main method executed

How Java Technology Change My Life

Posted by: Instanceofjava Posted date: April 13, 2015 / comment : 0 Java SE

We can not promise you fame, fortune or even a job if you learn the Java Programming
Still , It is likely to make your programs better and requires less effort than other languages.
We believe that Java technology will help you do the following.

1. Get Started Quickly:

Although the java programming is powerful object oriented language, its easy to learn.

2.Write less code

Comparisons of program metrics(class count , method count and so on.) suggest that a program written in java programming language can be four times smaller than the same program written in C++.

3.Write Better code:

Java Programming language encourages good coding practices and automatic garbage collection helps you avoid memory leak.

4.Develop programs more quickly:

The Java programming language is simpler than C++ and as such , your development time could be up to twice as fast when writing in it.
Your programs also require fewer lines of code.

5.Avoid platform dependencies:

You can keep your program portable by avoiding the use of libraries written in other languages.

6.Write once run anywhere:

Because applications written in the java programming language are compiled into machine independent bytecode, they run consistently on any java platform.

7.Distribute software more easily:

With Java web start software , users will be able to launch your application with a single click of the mouse .
An automatic version check at start up ensures that users are always up to date with the latest version of your software .
If an update is available , the java web start software will automatically update their installation.

What can Java Technology Do?

The general purpose , high level java programming language is powerful software platform.
Every full implementation of the java platform gives you the following features.

Development Tools:

The development tools provide everything you will need for
compiling ,
running ,
mongering,
debugging and documenting your application.

Application Programming Interface(API):

The API provides the core functionality of the java programming language . It offers a wide array of useful classes ready for use in your own applications.

Deployment Technologies:

The JDK software provides standard mechanism such as the java web start software and java plug in software for developing your applications to end users.

User Interface Tool-kits:

The swing and Java 2D tool kits make it possible to create sophisticated Graphical User Interfaces(GUIs).

Integration Libraries:

Integration libraries such as Java IDL API, JDBC API, Java Naming and Directory Interface(JNDI) API, Java RMI and Java remote method invocation over Internet inter -ORB protocol Technology(Java RMI-IIOP technology) enable database access and manipulation of remote objects.

Static import In java

Posted by: Instanceofjava Posted date: March 31, 2015 / comment : 0 Java SE

If we want to use any predefined class or user defined class or interface or enum which is present in a package we need to import those entire packages or those classes so that we can use those classes present inside the package.

import packagename.ClassTest;
import packagename.*;
For example if we want to read some data from keyboard we can use scanner class present in util package.
import java.util.Scanner;
We can import everything inside a package by using .*
import java.util.*;
Without importing want to use that class then code seems to like this

package com.instanceofjava;
class A{
public static void main(String [] args){
int number;
java.util.Scanner in = new java.util.Scanner(System.in);
System.out.println("Enter a number to check even or odd");
number=in.nextInt();
}
}

if we use import no need to mention class name in declaration

package com.instanceofjava;
import java.util.Scanner;
class A{
public static void main(String [] args){
int number;
Scanner in = new Scanner(System.in);
System.out.println("Enter a number to check even or odd");
number=in.nextInt();
}
}

Static import:

Normal imports will import the all the classes so that we can use them. similarly static imports will import all static data so that can use without class name.
Static imports introduced in Java 5.
Lets see one program without static import.

Without Static Import:

package com.instanceofjava;
class StaticImport{
public static void main(String [] args){
System.out.println(Math.PI); //3.141592653589793
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.parseInt("123"));//123
}
}

Using Static import:

static import in java with example:

package com.instanceofjava;
import static java.lang.Integer.*;
import static java.lang.Math.*;
class StaticImport{
public static void main(String [] args){
System.out.println(PI); //3.141592653589793
System.out.println(MAX_VALUE);//2147483647
System.out.println(parseInt("123"));//123
}
}

static imports in java 1.5 examples:

Importing Math class:

package com.instanceofjava;
import static java.lang.Math.*;
class StaticImport{
public static void main(String [] args){
System.out.println(PI); //3.141592653589793
double square;
double d1 = 3.0;
double d2 = 4.0;
square = sqrt(pow(d1, 2) + pow(d2, 2));
System.out.println(square);
}
}

Importing System class:

package com.instanceofjava;
import static java.lang.System.out;
class StaticImport{
public static void main(String [] args){
out.println("Good morning, " + "java2s");
out.println("Have a day!");
}
}

Importing User defined classes:

package com.instanceofjava;
class Colors{
public static int white = 1;
public static int black = 2;
public static int red = 3;
public static int blue = 4;
public static int orange = 5;
public static int grey = 6;
public static int green =7;
}

package com.instanceofjava;
import static com.instanceofjava.Colors.*;
class StaticImportDemo{
public static void main(String [] args){
System.out.println(white );//1
System.out.println(blue);//4
}
}

Arrays and Collections:

package com.instanceofjava;
import static com.instanceofjava.Colors.*;
class StaticImportDemo{
public static void main(String [] args){
int[] array = new int[] {5, 4, 6, 3, 2, 1};
sort(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
ArrayList al= new ArrayList();
al.add(1);
al.add(12);
al.add(3);
al.add(2);
sort(al);
Iterator itr= al.iterator();
while(itr.hasNext()){
System.out.printl(itr.next()+" ");
}
}
}

OutPut:

1 2 3 4 5 6
1 2 3 12

Advantages and Disadvantages of Static imports in java:

One of the advantage of using static imports is reducing keystrokes and re usability.
System.out.println() ; we can write as out.println() . But using eclipse short cut syso (ctrl+sapce) gives System.out.println() faster than static imports usage.
And there may be a chance of complexity in readability.
If we use class name before method like Math.sqrt() then can understand easily that method belongs to particular class . with static imports reduces readability.
One more disadvantage is naming conflicts.
If we use Integer.Max_value we cannot use Float.Max_value

Java programming interview questions

ObjectInputStream and ObjectOutputStream

Posted by: Instanceofjava Posted date: March 01, 2015 / comment : 0 Java SE

ObjectInputStream and ObjectOutputStream classes are used to store objects state permanently in files or to send to remote computer via network.
ObjectOutputStream class is subclass of ObjectOutput interface. It implements below method to write object to underline output stream.

public void writeObject(Object ob)throws IOException

ObjectInputStream class is a subclass of ObjectInput interface. It implements below method to read object to underline output stream.

public Object readObject() throws IOException

Rule:

To write or send object to external world it must be java.io.Serializable interface type.
It means this objects class must be a sub class of java.io.Serializable interface, else write() method throws java.io.NotSerializableException.

Constructors to create above two classes objects:

Like DataInputStream and DataOutputStream , ObjectInputStream and ObjectOutputStream are also can not connect to source and destination directly. So their constructors take other input and output stream class objects.

public ObjectInputStream(InputStream in)
public ObjectOutputStream(OutputStream out)

package instanceofjava;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class SerDemo implements Serializable {
String name;
String phonum;
String address;
int pin;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhonum() {
return phonum;
}
public void setPhonum(String phonum) {
this.phonum = phonum;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getPin() {
return pin;
}
public void setPin(int pin) {
this.pin = pin;
}
public static void main(String[] args)throws Exception{
SerDemo empobj= new SerDemo();
empobj.setName("sai");
empobj.setAddress("xxx, xxxstreet ");
empobj.setPhonum("040-9999999");
empobj.setPin(500072);
ObjectOutputStream oos= new ObjectOutputStream(new
FileOutputStream("E:\\employee.ser"));
oos.writeObject(empobj);
}
}

package instanceofjava;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class DeserDemo {
public static void main(String[] args)throws Exception{
ObjectInputStream ois= new ObjectInputStream(new FileInputStream("E:\\employee.ser"));
SerDemo obj= (SerDemo)ois.readObject();
System.out.println(obj.getAddress()):
}
}

Output:

sai
xxx, xxxstreet
500072
040-9999999

This is the actual functionality of ObjectOutputStream and ObjectInputStream: Serialization and deserialization

Serialization:

Serialization is the process of converting objects into stream of bytes and sending them to underlying output stream.
Using serialization we can store object state permanently in a destination , for example on remote computer.
Serialization operation performed by the writeObject() method of ObjectOutputStream.

Deserialization:

Deserialization is the process of converting stream of bytes into original object.
Deserialization operation is performed by readObject() of ObjectInputStream.

Rule:

Only java.io.serializable type objects are serialized. Serializable is a marker interface, it does not have any methods.
It provides special permission or identity to JVM to serialize Object.
If the given object is not of type serializable interface then writeObject() will throw an unchecked exception called java.io.NotSerializableException.

DataInputStream and DataOutPutStream

Posted by: Instanceofjava Posted date: March 01, 2015 / comment : 0 Java SE

These classes are used to read and write data as primitive type from the underlying InputStreams and Output Streams.
DataInputStream and DataOutputStream classes have special methods to perform reading and writing operations as primitive data.

DataInputStream:

DataInputStream is a sub class of FilterInputStream and DataInput Interface.
It implements below methods from the DataInput interface for reading bytes from a binary stream and convert them in to corresponding java primitive type.

DataInputStream methods:

public byte readByte()
public short readShort()
public int readInt()
public long readLong()
public float readFloat()
public double readDouble()
public char readChar()
public boolean readBoolean()
public String readUTF()
public String readLine()

DataOutPutStream:

DataOutputStream class is a subclass of FilterOutputStream and DataOutput interface.
It implements below methods from DataOutput interface for converting data of any java primitive types to a stream of bytes and writing these bytes to a binary stream.

DataOutPutStream Methods:

public void writeByte(byte b)
public void writeShort(short s)
public void writeInt(int i)
public void writeLong(long l)
public void writeFloat(float f)
public void writeDouble(double d)
public void writeChar(char ch)
public void writeBoolean(boolean b)
public void writeUTF(String s)
public void writeBytes(String s)

To read data as primitive types using above readXxx() methods , the data must be written to the file as primitive types using writeXxx() methods.
readXxx() methods must be called in the same order in which the writeXxx() methods are called otherwise wrong value will be returned or EOFException will occur.

Program to Write data as primitive type using DataInputStream

package instanceofjava;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class DOSDemo {
public static void main(String [] args) throws Exception{
FileOutputStream fos= new FileOutputStream("data.txt");
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(37);
dos.writeFloat(2.15f);
dos.writeChar('c');
dos.writeBoolean(true);
dos.writeUTF("instance of java");
}
}

After compilation and execution in current working directory you can find the "data.txt".
Check data.txt file size.
To check file size "right click on the file"-> click on properties
You will get size = size of all primitive data types mentioned in program check it.
From this program we can prove boolean takes 1 byte, the minimum memory location size in java is 1 byte.
For string data including double quotes JVM provides 1 byte for each character.

Program to Read data as primitive type using DataOutputStream

package instanceofjava;
import java.io.DataInputStream;
import java.io.FileInputStream;
public class DISDemo {
public static void main(String [] args) throws Exception{
FileInputStream fis= new FileInputStream("D:\\data.txt");
DataInputStream dis = new DataInputStream(fis);
int i= dis.readInt();
float f=dis.readFloat();
char ch=dis.readChar();
boolean b=dis.readBoolean();
String str= dis.readUTF();
System.out.println(i);
System.out.println(f);
System.out.println(ch);
System.out.println(b);
System.out.println(str);
}
}

Execute the above application by changing readXxx() methods calling order.
Then check you will get right value or not.
Actually readXxx() method read number of bytes from the file based on the data type.
For example if we call readInt() method it read 4 bytes from file.
So if our bytes are available in file program executed fine, execution terminates with EOFException.

Limitations in DataInputStream and DataOutputStream:

Using DataInputStream and DataOutputstream we can not read and write objects from persistence media.
They have only capability to read data up to only primitive data types.

Solution:

To read and write objects we must use ObjectInputStream and ObjectOutputStream.

Java 8 Interface Static and Default Methods

Posted by: Instanceofjava Posted date: February 22, 2015 / comment : 2 Java 8 , Java SE

Java 8 introduced two new methods in interface they are
1.default methods
2.static methods
By this interfaces and abstract class are same but still having lot differences like abstract class can have a constructor etc will discuss more before that we need to know about these Java 8 features of interfaces.
Defaults methods are also called as defender methods can be implemented inside the interface
Like normal class now with java 8 we can declare static methods in side a interface.
Lets jump deep into Java 8 default and static methods

1.Interface Default Methods in Java 8

Before Java 8 in interfaces we can and able to declare only abstract methods only.
If we declare a method without abstract that will be treated as abstract by default.
As we know all methods in interfaces are by default abstract methods.
These methods wont have body means implementations
The class which is implementing this interface need to provide body / implementation for this abstract methods.
Now with java 8 default methods we can add methods to interface without disturbing existing functionality.
So instead of overriding now we can inherit these default methods from interfaces

Defaults methods are also known as defender methods or virtual extension methods
Default methods will help us to avoid utility classes.
We can define utility methods inside the interface and use it in all classes which is implementing.
One of the major reason to introduce this default methods in java 8 is to support lambda expressions in collections API and to enhance.

package com.instanceofjava;
interface Java8Interface{
abstract void show();
default void display(){
System.out.println("default method of interface");
}
}

package com.instanceofjava;
class Sample implements Java8Interface {
void show(){
System.out.print("overridden method ")
}
public static void main(String[] args){
Sample obj= new Sample();
obj.show(); // calling implemented method
obj.display(); // calling inherited method
Java8Interface.display(); calling using interface name
}
}

Output:

overridden method
default method of interface
default method of interface

How to call default methods:

We can all these default methods by using interface name and also by using object of the class which is implementing.
From above example
obj.show(); // calling implemented method
obj.display(); // calling inherited method
Java8Interface.display(); calling using interface name

Can we override java 8 default method

As we discussed above default methods in interfaces are implemented methods with bodies
Yes we can override same method in class which is implementing this interface.
Lets see one sample program how to override and what happens if we override

package com.instanceofjava;
interface InterfaceWithDefault{
default void defMethod(){
System.out.println("default method of interface");
}
}

package com.instanceofjava;
class Demo implements InterfaceWithDefault{
void defMethod(){
System.out.print("overridden method in class Demo ")
}
public static void main(String[] args){
Demo obj= new Demo();
obj.defMethod(); // calling overridden method
Java8Interface.defMethod(); calling using interface name : interface defMethod will be called
}
}

Output:

overridden method in class Demo
default method of interface

What happens if we implement two interfaces having same default methods

Now lets see if a class implementing two interfaces which are having same default methods
Whatever the implementation in the two interfaces defined if we implementing two interfaces which are having a default method in both then compilation error will come if two methods have same signature. works fine if two methods have same name with different arguments.
Check the below example programs to understand more.

package com.instanceofjava;
interface A{
default void defMethod(){
System.out.println("default method of interface: A");
}
}

package com.instanceofjava;
interface B{
default void defMethod(){
System.out.println("default method of interface: B");
}
}

package com.instanceofjava;
class Demo implements A, B{ // compilation error will come
public static void main(String[] args){
Demo obj= new Demo();
}
}

If we implement two interfaces which are having same method with same parameters then compilation error will occur.
Duplicate default methods named "defMethod" with the parameters () and () are inherited from the types A and B.
If we define two methods with different type of parameters then we can work with both interfaces.

package com.instanceofjava;
interface A{
default void defMethod(){
System.out.println("Default method of interface: A");
}
}

package com.instanceofjava;
interface B{
default void defMethod(String str){
System.out.println("Default method of interface: B");
System.out.println(str);
}
}

package com.instanceofjava;
class Demo implements A, B{ // compilation error will come
public static void main(String[] args){
Demo obj= new Demo();
obj.defMethod();
obj.defMethod("Java 8")
}
}

Output:

Default method of interface: A
Default method of interface: B
Java 8

1.Interface Static Methods in Java 8

Another Java 8 interface method is static method.
Now we can define static methods inside interface but we can not override these static methods.
These static method will act as helper methods.
These methods are the parts of interface not belongs to implementation class objects.

package com.instanceofjava;
interface StaticInterface{
Static void print(String str){
System.out.println("Static method of interface:"+str);
}
}

package com.instanceofjava;
class Demo implements StaticInterface{
public static void main(String[] args){
StaticInterface.print("Java 8")
}
}

Output:

Static method of interface: Java 8

8 New Java 8 Features

Posted by: Instanceofjava Posted date: February 16, 2015 / comment : 1 Java 8 , Java SE

Default and Static methods in Interface
Lambda Expressions
Optional
Streams
Method References
Data Time API
Nashorn Javascript Engine
Parallel Arrays

1.Default and Static methods in Interface :

Java 8 introduces new features to interfaces.
Before java 8 interface having only abstract methods but now java 8 added two more type of methods to interface !.
First one is default method. A method which is having a default keyword with method body.
Actually interfaces wont have any implemented methods but now with java 8 default method we can add a method with default implementation by using "default " keyword.
The classes which are implementing this interface can use these default method and same time it can override the existing method. But its not mandatory to override.

package com.instanceofjava;
interface Java8InterfaceDemo{
abstract void add();
default void display(){
System.out.println("default method of interface");
}
}

The second new method introduced in java 8 is static method.
Yes like in classes now we can define a static methods inside interface by using "static".
Basically static methods which are defined in interface are interface level only. if we want to call these static methods which are defined in interfaces we need to use interface name so that we can access these methods.

package com.instanceofjava;
interface Java8InterfaceDemo{
abstract void add();
default void display(){
System.out.println("default method of interface");
}
public static void show(){
System.out.println("static method of interface");
}
}

2.Lambda Expressions

One of the most awaited and biggest release in java 8 is lamda expressions.
Ability to pass functionality/ behavior to methods as arguments.
Allows us to write a method in the same place we are going to use it.

package com.instanceofjava;
interface JavalamdaExpression{
public static void main(String[] args){
Arrays.asList( "j", "a", "v" ,"a","8").forEach( e -> System.out.print( e ) );
// java8
}
}

3.java.util.Optional:

One of the best and cool feature of java 8 is Optional class. Which is a final calls from java.util package.
The major repeating statement in every project is checking "NullPointerException". Before using any object we need to check whether it is null or not if its not null then only we need to proceed.
Optional is just like a container which holds a value of type <T> or "null". By using isPresent() method of Optional class we can check particular object is null not not.

package com.instanceofjava;
import java.util.Optional:
class Java8OptionalDemo{
public static void main(String[] args ){
Optional< String > str = Optional.ofNullable( null );
System.out.println( "str having value ? " + str.isPresent() ); // output : str having value ? false
}
}

4.Streams:

One of the excellent feature from java 8 as java.util.stream.
Stream API introduces real-world functional-style programming into the Java.
Provides functional operations on stream of elements such as list , set and map
Supports filtering, mapping and removal of duplicates of elements in collections, are implemented lazily.
Now we can get Streams from collections, arrays and bufferedReaders etc.

package com.instanceofjava;
import java.util.Arrays;
class Java8StreamsDemo{
public static void main(String[] args ){
Arrays.stream(new int[] {1, 2, 3,4,5})
.map(n -> 2 * n + 1)
.average()
.ifPresent(System.out::println); // output: 7.0
}
}

5.Method Reference:

We can use lambda expressions to create anonymous methods.
Sometimes, however, a lambda expression does nothing but call an existing method.
In those cases, it's often clearer to refer to the existing method by name.
Using Method references refer to the existing method by name, they are compact, easy-to-read lambda expressions for methods that already have a name

package com.instanceofjava;
import java.util.Arrays;
class Java8MethodRef{
public void show(String str){
System.out.println(str);
}
public static void main(String[] args ){
Arrays.asList("a", "b", "c").forEach(new A()::show); // a b c
}
}

6.Data Time API

The next cool feature from java 8 is new date time API(jsr 310) added within java.time package.
Before java 8 if we want to format dates we use SimpleDateFormatter class in java 8 while declaring date itself it has constructor to pass format of date.
Some of the new classes introduced in java 8 date time are as follows.

LocalTime
LocalDate
LocalDateTime
OffsetDate
OffsetTime
OffsetDateTime

package com.instanceofjava;
import java.util.Arrays;
class Java8DateTimeAPI{
public static void main(String[] args ){
LocalDate currentDate = LocalDate.now();
System.out.println(currentDate);
LocalDate twentyMarch2015 = LocalDate.of(2015, Month.MARCH, 06);
System.out.println(twentyMarch2015); //2015-03-06
LocalDate firstApril2015 = LocalDate.of(2015, 4, 1);
System.out.println(firstApril2015);//2015-04-01
}
}

7.Nashorn Javascript Engine

Java 8 come with new Nashorn Javascript Engine which is allowing us to develop and run JavaScript applications.

package com.instanceofjava;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Arrays;
class Java8JavaScript{
public static void main(String[] args ){
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName( "JavaScript" );
System.out.println( engine.getClass().getName() );
System.out.println( "output:" + engine.eval( "function show() { return 10; }; show();" ) );
}
}

jdk.nashorn.api.scripting.NashornScriptEngine
output:10

8.Parallel Array Sorting

As of now java 7 we already having Arrays.sort() method to sort objects now java 8 introduced parallel sorting which has more speed than arrays.sort() and follows Fork/Join framework introduced in Java 7 to assign the sorting tasks to multiple threads that are available in the thread pool.
Java 8 added parallel sorting functionalities to java.util.Arrays to take advantage of multithread machines

package com.instanceofjava;
import java.util.Arrays;
class Java8JavaScript{
public static void main(String[] args ){
int arr[]={1,4,2,8,5};
Arrays.parallelSort(arr);
for(int i:arr){
System.out.println(i);
}
}
}