InstanceOfJava

Inheritance programming interview questions

Posted by: Instanceofjava Posted date: 4:03 PM / comment : 2 Find Output of Program

1. what is the output of following program:

package com.instanceofjava;
public class SuperDemo{
public void show(){
System.out.println("super class method called");
}
}

package com.instanceofjava;
public class SubDemo extends SuperDemo{
public void show(){
System.out.println("sub class method called");
}
public static void main(String args[]){
SubDemo subobj=new SubDemo();
subobj.show();
}

2. what is the output of following program:

package com.instanceofjava;
public class SuperDemo{
int x;
}

package com.instanceofjava;
public class SubDemo extends SuperDemo{
int y;
public void show(){
super.x=y+2;
System.out.println("x="+super.x+"y="+y);
}
public static void main(String args[]){
SubDemo subobj=new SubDemo();
subobj.show();
}

3. what is the output of following program:

package com.instanceofjava;
public class SuperDemo {
int x;
}

package com.instanceofjava;
public class SubDemo extends SuperDemo{
int y;
public void show(){
super.x=y+2;
System.out.println("x="+super.x+"y="+y);
}
public static void main(String args[]){
SubDemo subobj=new SubDemo();
subobj.x=2;
subobj.y=2;
subobj.show();
}

4. what is the output of following program:

package com.instanceofjava;
public class SuperDemo{
int x;
SuperDemo(){
x=24;
}
}

package com.instanceofjava;
public class SubDemo extends SuperDemo{
int y;
public void show(){
System.out.println("x="+super.x);
System.out.println("y="+y);
}
public static void main(String args[]){
SubDemo subobj=new SubDemo();
subobj.show();
}

Arrays in java

Posted by: Instanceofjava Posted date: 1:20 PM / comment : 0 Java SE

Array:

Array is referenced data type used to store multiple values.
we can not change size of array at runtime.
memory can not be altered Once the memory has been allocated for an array at the run time.
Arrays are objects

Need of array:

In real time projects array is used to collect same type of objects to send all values with single method call.

Problem of primitive data types:

We can not store values in continuous memory locations using primitive data types .
We have two problems due to this limitation

1.we cant store multiple values:

If we want to store multiple values , say 1 to 10 , we must create 10 variables .
All those 10 variables are created at different locations.

2.In single method call we can not pass multiple values :

we can not pass all values to the remote computer with single network call or method call.Using primitive variables , which increases burden on network and also increase number of lines of code in program.

Solution:

Values must be stored in continuous memory locations with single variable name. To solve above two problems ,
This can be possible using array.
In java array is reference data type . it is used to store fixed number of multiple values of same type in continuous memory locations.
Like other data types array is not a keyword it is a concept. it creates continuous memory locations using other primitive or reference types.

Array Limitation:

Array size is fixed , means we can not increase or decrease its size after its creation.

Array Declaration:

<Accessibility modifier><Modifier><datatype>[] <array variable name>;

For example:

public static int[] i;
public static Example[] e;
Like in C or C++ , in java we can not mention array size in declaration part. It leads Compile time error.
int[5] i; Compile time Error: illegal start of expression
int [] i;

Possible declaration:

After data type : int[] i;
Before variable name : int []i;
After variable name : int i[];

Type of arrays:

Single dimensional : int [] i;
Two dimensional : int[][] i;
Three dimensional : int [][][] i;

Array object creation:

<Accessibility Modifier><Modifier><data type>[]<array name>={<list of values with , separator>};
int [] ia={10,20,30,40};

Super keyword

Posted by: Instanceofjava Posted date: 11:32 AM / comment : 1 Java SE

super:

The functionality of super keyword is only to point the immediate super class object of the current object.
super keyword is applicable only in the non static methods and super keyword not applicable in the static methods.
super keyword used to access the members of the super class object.
super.member;
It is used to store super class non static members memory reference through current sub class object for separating super class members from subclass members.

Uses:

Using super keyword we can explicitly point the immediate super class object and access all the super class members which are present with the same name of the subclass members from the sub class methods.

package com.instanceofjavaforus;
public Class SuperDemo{
int a,b;
public void show() {
System.out.println(a);
System.out.println(b);
}
}

package com.instanceofjavaforus;
public Class Subdemo{
int a,b;
void disply(){
System.out.println(a);
System.out.println(b);
super.a=10;
super.b=20;
super.show();
}
public static void main (String args[]) {
Subdemo obj= new Subdemo();
obj.a=1;
obj.b=2;
obj.disply();
}
}
Output:
1
2
10
20

Using super keyword we can explicitly call the super class constructor.
The statement which explicitly calling super class constructor should be always the first statement of the sub class constructor.
The statement which explicitly calls the super class constructor should be present inside a constructor only.

package com.instanceofjavaforus;
public Class SuperDemo{
int a,b;
public void show() {
System.out.println(a);
System.out.println(b);
}
SuperDemo(int x, int y){
a=x;
b=y
}
}

package com.instanceofjavaforus;
public Class Subdemo{
int a,b;
SubDemo(int x, int y){
super(10,20);
a=x;
b=y
}
void disply(){
System.out.println(a);
System.out.println(b);
super.show();
}
public static void main (String args[]) {
Subdemo obj= new Subdemo(1,2);
obj.disply();
}
}
Output:
1
2
10
20

Key points to remember:

It is a keyword used to store super class non static members reference in subclass object.
Pre defined instance variable used to hold super class object reference through sub class object.
Used to separate super class and sub class members if both have same name.
It must be used explicitly if super class and sub class members have the same name.
Used to call super class constructor from sub class constructor.

Factory Method Pattern

Posted by: Instanceofjava Posted date: 11:26 PM / comment : 0 Design Pattern , Java SE

Factory Method Pattern:

Problem: Using new keyword we can not create object with flexibility and by applying restrictions.
Solution: Use Factory pattern (or) Factory method.
By defining a abstract class or an interface but let the subclass decide which class object to instantiate.
A method of a class capable of constructing and returning its own class object or other class object is called "factory method".
There are two types of factory methods.

Static factory method.
Instance factory method.

1.Static Factory method:

A static method defined to construct and return object of same class or different is known as static factory method.
Some of the pre defined static factory methods are as follows.

Thread th= Thread.currentThread();
Class c=Class.forName();
Runtime rt=Runtime.getRuntime();
Calendar c=Calendar.getInstance();

2.Instance Factory method:

A non static method defined to construct and return object of same class or different is known as instance factory method.
Some of the pre defined instance factory methods are as follows.

String s= new String("instance of");
String s1=s.concat("java");
StringBuffer sb=new StringBuffer("instance of");
sb=sb.subString(0,2);
Date d= new Date();
String s=d.toString();

Program on Factory method / Factory Design pattern:

Step 1: create an interface:

package com.instanceofjavaforus;
public interface Vehicle {
public void engine();
}

Step 2: create a Two Wheeler class which implements vehicle interface:

package com.instanceofjavaforus;
public class TwoWheeler implements Vehicle {
@Override
public void engine() {
System.out.println("Two Wheeler");
}
}

Step 3:: create a Four Wheeler class which implements vehicle interface:

package com.instanceofjavaforus;
public class FourWheeler implements Vehicle {
@Override
public void engine() {
System.out.println("FourWheeler");
}
}

Step 4: create a SixWheeler class which implements vehicle interface:

package com.instanceofjavaforus;
public class SixWheeler implements Vehicle {
@Override
public void engine() {
System.out.println("SixWheeler");
}
}

Step 5: create a TestEngine class which is having factory method:

package com.instanceofjavaforus;
public class TestEngine {
public Vehicle getVehicle(String venname){
if(venname==null){
return null;
}else if(venname.equalsIgnoreCase("TwoWheeler")){
return new TwoWheeler();
}else if(venname.equalsIgnoreCase("FourWheeler")){
return new FourWheeler();
}else if(venname.equalsIgnoreCase("SixWheeler")){
return new SixWheeler();
}
return null;
}
}

Step 6: create a FactoryDemo class:

package com.instanceofjavaforus;
public class FactoryDemo {
public static void main(String args[]){
TestEngine te= new TestEngine();
Vehicle vehcle1=te.getVehicle("TwoWheeler");
vehcle1.engine();
Vehicle vehcle2=te.getVehicle("FourWheeler");
vehcle2.engine();
Vehicle vehcle3=te.getVehicle("SixWheeler");
vehcle3.engine();
}
}

OutPut:
TwoWheeler
FourWheeler
SixWheeler

Design patterns in java

Posted by: Instanceofjava Posted date: 10:20 PM / comment : 2 Design Pattern , Java SE

Design patterns:

Pattern means set of guide lines.
Design patterns are solutions to commonly reoccurring problems in software development.
Design patterns are well proven solutions to common software problems.
Design patterns are best practices to use software technologies effectively in application development.
Design patterns used in analysis and requirement phase of SDLC.
Design patterns can be implemented by using programming language.

Advantages:

Reusable.
These are already defined solutions to common re occurring problems so it reduces time.
They are already defined so Easy to understand and debug.

Categorization:

These are categorized into two parts.

Java SE Design patterns.
Java EE Design patterns.

Java SE Design patterns:

In Java SE there are mainly three types.

1.Creational Design patterns:

Factory Pattern
Abstract Factory Pattern
Singleton Pattern
Prototype Pattern
Builder Pattern.

2.Structural Design patterns:

Adapter Pattern
Bridge Pattern
Composite Pattern
Decorator Pattern
Facade Pattern
Flyweight Pattern
Proxy Pattern

3.Behavioral Design patterns:

Chain Of Responsibility Pattern
Command Pattern
Interpreter Pattern
Iterator Pattern
Mediator Pattern
Memento Pattern
Observer Pattern
State Pattern
Strategy Pattern
Template Pattern
Visitor Pattern

Sort ArrayList in descending order

Posted by: Instanceofjava Posted date: 10:49 AM / comment : 0 Java Programs

Descending order:

package com.instanceofjavaforus;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class SortArrayListDesc {
public static void main(String[] args) {
//create an ArrayList object
ArrayList arrayList = new ArrayList();
//Add elements to Arraylist
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
arrayList.add(5);
arrayList.add(6);
/*
Use static Comparator reverseOrder() method of Collections
utility class to get comparator object
*/
Comparator comparator = Collections.reverseOrder();
System.out.println("Before sorting : " + arrayList);
/*
use
static void sort(List list, Comparator com) method of Collections class.
*/
Collections.sort(arrayList,comparator);
System.out.println("After sorting : + arrayList);
}
}

OutPut:
Before sorting : [1, 2, 3, 4, 5, 6]
After sorting : [6, 5, 4, 3, 2, 1]

Ascending order:

package com.instanceofjavaforus;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class SortArrayListAsc{
public static void main(String[] args) {
//create an ArrayList object
ArrayList arrayList = new ArrayList();
//Add elements to Arraylist
arrayList.add(10);
arrayList.add(4);
arrayList.add(7);
arrayList.add(2);
arrayList.add(5);
arrayList.add(3);
System.out.println("Before sorting : " + arrayList);
/*
use
static void sort(List list) method of Collections class.
*/
Collections.sort(arrayList);
System.out.println("After sorting : + arrayList);
}
}

OutPut:
Before sorting : [10, 4, 7, 2, 5, 3]
After sorting : [2, 3, 4, 5, 7, 10]

Subscribe to: Posts ( Atom )