InstanceOfJava

Polymorphism

Posted by: Instanceofjava Posted date: 8:32 PM / comment : 0 concept and program

Defining multiple methods with same name
Static polymorphism and dynamic polymorphism

Static polymorphism:

Its a process of defining multiple methods with the same name and with different parameter types or list or order is called static polymorphism
Compile time itself we can say which method is going to get executed based on parameters types.
So its also called compile time polymorphism.
This will be achieved by method overloading.
Method overloading means defining multiple methods with same name and different parameters.
If two methods have same method name , But different parameter types those methods are considered as overloaded methods.
Will see example program on method overloading.

Example program on method overloading:

package instanceofjava;
public class OverloadingDemo {
void add(){
System.out.println("No-arg method");
}
void add(int i){
System.out.println("int-arg method");
}
void add(String str){
System.out.println("String-arg method");
}
void add(float d){
System.out.println("float-arg method");
}
void add(int a, int b){
System.out.println("2 int-arg method");
}
public static void main(String[] args){
OverloadingDemo obj= new OverloadingDemo();
obj.add();
obj.add(10);
obj.add(1.2f);
obj.add("java");
obj.add(1, 2);
}
}

Output

No-arg method
int-arg method
float-arg method
String-arg method
2 int-arg method

Method overloading with reference types:

We can also overload method with reference types, check below program.

package instanceofjava;
public class Test {
void show(){
System.out.println("test class show() method");
}
}

package instanceofjava;
public class Example {
void method(String s){
System.out.println("String-arg");
}
void method(Test obj){
System.out.println("method(Test obj)-arg");
obj.show();
}
public static void main(String[] args){
Example obj= new Example();
obj.method("polymorphism definition in oops");
obj.method(new Test());
}
}

Output:

String-arg
method(Test obj)-arg
test class show() method

Dynamic polymorphism:

Redefining the super class method in sub class is called "method overriding" .
Method overriding is a language feature that allows a sub class to provide a specific implementation of a method that is already provided by one of its super class.
The implementation in the sub class overrides the implementation in the super class.
This is also called dynamic polymorphism / runtime polymorphism.

package instanceofjava;
public class A{
void show(String s){
System.out.println("super class method");
}
}

package instanceofjava;
public class B extends A{
void show(String s){
System.out.println("sub class method");
}
public static void main(String[] args){
B obj =new B();
obj.show();
}
}

Output:

sub class method

We can not override static methods:

Actually static variables and static methods are class level. they are not instance level.
So if you try to override a static method will throw compile error

package instanceofjava;
public class Super {
int a,b;
static void add(){
System.out.println("super class add() method");
}
}

package instanceofjava;
public class Sub extends Super {
void add(){ // ERROR:This instance method cannot override the static method
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Sub obj= new Sub();
}
}

Static methods are class level so we need to access by using class name.

package instanceofjava;
public class Sub extends Super {
static void add(){// works fine
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Super.add();
Sub.add();
}
}

Output:

super class add() method
sub class add() method

Method Overriding - Exceptions:

When we overriding a method from super class to sub class. we need to follow some rules
Whenever sub class method throws checked exception then super class method must be declared throws with same exception or super class of that checked exception.

package instanceofjava;
public class Super {
int a,b;
void add(){
System.out.println("super class add() method");
}
}

package instanceofjava;
public class Sub extends Super {
void add() throws IOException{ // ERROR: - Exception IOException is not compatible with
//throws clause in Super.add()
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Sub obj= new Sub();
}
}

package instanceofjava;
public class Super {
int a,b;
void add()throws IOException{
System.out.println("super class add() method");
}
}

package instanceofjava;
public class Sub extends Super {
void add() throws IOException{// works fine
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Sub obj= new Sub();
}
}

Inheritance Definition and Programs

Posted by: Instanceofjava Posted date: 2:55 PM / comment : 0 concept and program

Getting the properties from one class object to other class is known as inheritance.
In this inheritance will have parent class and child class so getting the properties of parent class object to child class object known as inheritance.
Inheritance means to take something that already made.
Inheritance can be implemented in java by using "extends" and "implements' keywords
In this we have two types.
Multilevel inheritance
Multiple inheritance

Multilevel inheritance:

Getting the properties from super class object to sub class object level wise with different priorities known as multiple inheritance.

Super class:

package instanceofjava;
public class Super {
int a,b;
void add(){
System.out.println((a+b));
}
}

Sub class:

package instanceofjava;
public class Sub extends Super {
void show(){
System.out.println("this is sub class show() method");
}
public static void main(String [] args){
Sub obj= new Sub();
obj.a=1;
obj.b=2;
obj.add();
obj.show();
}
}

Output:

3
this is sub class show() method

Example program #2:

package instanceofjava;
public class A {
int a,b;
public void show(){
System.out.println("A class show method");
}
}

package instanceofjava;
public class B extends A{
public void print(){
System.out.println("B class print method");
}
}

package instanceofjava;
public class C extends B{
public void display(){
System.out.println("C class display method");
}
public static void main(String [] args){
C obj= new C();
obj.print();
obj.show();
obj.display();
}
}

Output:

B class print() method
A class show method
Class C display method

Multiple inheritance:

Multiple inheritance means getting the properties from one class object to multiple class object with different priority.
Multiple inheritance concept is not supported by java

package instanceofjava;
public class A {
public void show(){
System.out.println("A class show method");
}
}

package instanceofjava;
public class b {
public void show(){
System.out.println("B class show method");
}
}

package instanceofjava;
public class C extends A,B { // not supported by java
public void print(){
System.out.println("C class print method");
}
}

Why java does not supports multiple inheritance check this for more information.

You Might Like:

1. Java Interview Programs On Core Java

2. Java Interview Programs On Collections

3. What is The Output Of Following Programs Java Interview:

4. Java Concept and Example Program

Encapsulation in java with example program

Posted by: Instanceofjava Posted date: 10:17 AM / comment : 2 concept and program

What is meant by encapsulation in java?

Binding the data with its related functionalities known as encapsulation
Here data means variables and functionalities means methods.
So keeping the variable and related methods in one place.
That place is "class". class is the base for encapsulation.
Lets see example program on encapsulation, how the variables and methods defined in a class

What is encapsulation in object oriented programming?

Basic java example program on data encapsulation:

package com.instanceofjava;
public class EncapsulationDemo {
String name;
int rno;
String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRno() {
return rno;
}
public void setRno(int rno) {
this.rno = rno;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public void showInfo(){
System.out.println("Name: "+getName());
System.out.println("R.No: "+getRno());
System.out.println("Name: "+getAddress());
}
}

Class:

The above example program shows how the variables and methods will be there in a class.
So class is the base for encapsulation
class is user defined data type in java means by using class we can structure our own programs.
Lest see a example program on class.

package com.instanceofjava;
public class ClassDemo {
//variables of a class
String empName;
int empId;
String Designation;
//getter and setter methods for variables
//by using these methods we can set the value to the variable and gat the value from the
//variables
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public String getDesignation() {
return Designation;
}
public void setDesignation(String designation) {
Designation = designation;
}
}

Object:

Instance of class is known as object.
Instance means dynamic memory allocation. So dynamic memory allocation to class is called object.
By using "new" keyword the object will be created dynamically.
Class is a template. By using object we will get memory for all variables so that we can use them.

We can create number of objects for one class based on our requirements.
Below an example program on class and object.

package com.instanceofjava;
public class User {
String Name;
int Id;
String address;
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public int getId() {
return Id;
}
public void setId(int id) {
Id = id;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public static void main(String [] args){
User obj= new User();
obj.setName("sai");
obj.setId(1);
obj.setAddress("xyz");
System.out.println(obj.getName());
System.out.println(obj.getId());
System.out.println(obj.getAddress());
}
}

Output:

Program Check even or odd without using modulus and division operators

Posted by: Instanceofjava Posted date: 2:49 PM / comment : 9 Java Programs

write a progrma to check number is even or odd without using modulus or divition

Checking the number even or odd program is very easy. Anybody can solve this but there is a condition we need to see.
When we get this question in interview "write a program to check given number is even or odd" always continues with "without using modulus and division operators".
Before going to actual program lets see how to check a number is even or odd by using modulus and division operators.

Program to check number is even or odd by using modulus "%" operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
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();
if((number % 2)==0){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
37
37 is Odd Number

Program to check number is even or odd by using division "/" operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
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();
if((number / 2)*2==number){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
46
46 is Even Number

Without using modulus and division operators:

The above two programs will check number is even or odd and displays result.
Now we need to write a program to check even or odd without using modulus and division operators.
It is very simple if you know about operators including "BIT WISE".
Yes using Bit Wise AND "&" operator we can check a number is even or odd.
Before starting our program lets see how this bit wise AND "&" operator will work.

Bitwise Operators :

Bit wise operators will work on bits at a time.
AND : 1 & 1=1
OR : 0 | 1= 1 , 1 | 0=1 , 1| 1= 1
XOR: 0 ^ 1= 1 , 1^ 0=1
NOT : !0=1

Take two number 2 and 3
010 : 2
011 : 3
------
010 : 2
------
Take two numbers 2 and 1
010 :2
001 :1
-----
000 :0
-----

From above example we can say that on every even number & 1 gives 0.
So this is our logic to be implemented in our program if "Number & 1==0" then its even number.

Program to check number is even or odd by using "&" operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
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();
if((number & 1)==0){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
9
9 is Odd Number

Using Shift Operators:

We can check even or odd by using shift operators also may be it is not a better solution but trying to cover alternative.
Lets see how shift operators will work
Lets do this 2 >> 1
2 means 010 so now we need to shift right side by 1 place
010
-----
001
Here we added one "0" to the left side to shift right
So the value became 1
Now will try left shift 001 >> 1
001
----
010
010<<1=001(1) and 001 >> 001=010(2)
By this we can say if a (number >>1)<<1 gives same then that is even number. result=input
Lets check for odd number 3
011>>1=001 which is 1 and 001<<1=010 which is 2 so (3>>1)>>1=2 so result!=input

Program to check number is even or odd by using Shift operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
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();
if( ( number >> 1) <<1==number){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
64
64 is Even Number

Here is the another solution for this.

package instanceofjava;
import java.util.Scanner;
class EvenOrOddDemo
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number to check whether it is even or odd without using Modulus
and Division: ");
int n=Integer.parseInt(sc.next());
float f=(float)n/(float)2;
int d=(int)f*2;
if(d==n)
System.out.println(n+" is a even number");
else
System.out.println(n+" is a odd number");
}
}

Output:

Enter a number to check whether it is even or odd without using Modulus and Division
4
4 is Even Number

ObjectInputStream and ObjectOutputStream

Posted by: Instanceofjava Posted date: 6:13 PM / 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: 1:22 PM / 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.

Subscribe to: Posts ( Atom )