InstanceOfJava: concept and program

concept and program

Static Members in java

Posted by: Instanceofjava Posted date: April 19, 2015 / comment : 2 concept and program

The class level members which have static keyword in their definition are called static members.

Types of Static Members:

Java supports four types of static members

All static members are identified and get memory location at the time of class loading by default by JVM in Method area.
Only static variables get memory location, methods will not have separate memory location like variables.
Static Methods are just identified and can be accessed directly without object creation.

1.Static Variable:

A class level variable which has static keyword in its creation statement is called static variable.

package com.instanceofjava;
class Demo{
static int a=10;
static int b=20;
}

We can not declare local variables as static it leads to compile time error "illegal start of expression".
Because being static variable it must get memory at the time of class loading, which is not possible to provide memory to local variable at the time of class loading.

package com.instanceofjava;
class Demo{
static int a=10;
static int b=20;
public static void main(String [] args){
//local variables should not be static
static int a=10;// compile time error: illegal start of expression
}

All static variables are executed by JVM in the order of they defined from top to bottom.
JVM provides individual memory location to each static variable in method area only once in a class life time.

Life time and scope:

Static variable get life as soon as class is loaded into JVM and is available till class is removed from JVM or JVM is shutdown.
And its scope is class scope means it is accessible throughout the class.

package com.instanceofjava;
class StaticDemo{
static int a=10;
static int b=20;
public static void main(String [] args){
System.out.println("a="+a);
System.out.println("a="+b);
show();
}
public static void show(){
System.out.println("a="+a);
System.out.println("a="+b);
}
}

Duplicate Variables:

If multiple variables are created with same name are considered as duplicate variables.
In the same scope we can not create multiple variables with same name.
If we create it leads to compile time error "variable is already defined".
Even if we change data type or modifier or its assigned value we can not create another variable with same name.

package com.instanceofjava;
class StaticDemo
{
static int a=10;
int a=30;// Compile time error
}

But it is possible to create multiple variables with same name in different scopes.

package com.instanceofjava;
class StaticDemo
{
static int a=10;
int a=30;// Compile time error
public static void main(String [] args){
// it is allowed to define "a" in this method.
int a=20;
}
}

Shadowing:

It is possible to create local variables or parameters with same variable name.
The concept is called shadowing . It means local variable is a shadow of class level variable.
It means when you access it in side method , you will get local variables value but not from class level.

package com.instanceofjava;
class StaticDemo
{
static int a=10;
public static void main(String [] args){
int a=20;
System.out.println("a="+a); // prints 20
}
}

Local preference:

When we call a variable compiler and JVM will search for its definition in that method first, if its definition is not found in that method then will search for its definition at class level.
If its definition not found at class level also then compiler throws error: can not find symbol.
This phenomenon is called local preference.

package com.instanceofjava;
class StaticDemo
{
static int a=10;
public static void main(String [] args){
System.out.println("a="+a); // prints 10 : method level no definition so access class level
int a=20;
System.out.println("a="+a); // prints 20 :method level variable found
}
}

By using class name we can get class level variables value.

package com.instanceofjava;
class StaticDemo
{
static int a=10;
public static void main(String [] args){
System.out.println("a="+a); // prints 10 : method level no definition so access class level
int a=20;
System.out.println("a="+a); // prints 20 :method level variable found
System.out.println("a="+StaticDemo.a); // prints 10 : class level variable
}
}

Order of execution of static variables and main method:

First all static variables are executed in the order they defined from top to bottom then main method is executed.

Example Program:

package com.instanceofjava;
class StaticDemo
{
static int a=m1();
static int m1(){
System.out.println("variable a is created");
return 10;
}
static int b=m2();
static int m2(){
System.out.println("variable b is created");
return 20;
}
public static void main(String [] args){
System.out.println("in main method");
System.out.println("a="+a);
System.out.println("b="+b);
}
}

Output:

variable a is created
variable b is created
in main method
10
20

we can access static fields using objects but static fields should be accessed in a static way because static fields are class level so even if we change field value using particular object that will change the original value

package com.instanceofjava;
public class StaticDemo {
static int x=10;
public static void main(String[] args) {
StaticDemo obj=new StaticDemo();
System.out.println(x);
obj.x=30;
System.out.println(x);
StaticDemo obj2=new StaticDemo();
System.out.println(obj2.x);
System.out.println(StaticDemo.x); // Recommended way to access static variables
}
}

Output:

Final Static Variables:

Final static variables are constants.
Declaration itself we need to assign value to the final static variables otherwise compiler error will come: "The blank final field may not have been initialized".
And we can not change this value if we try then compiler error will come: The final field cannot be assigned.

package com.instanceofjava;
class Demo{
final static int MAX_VALUE=10;
public static void main(String [] args){
System.out.println(MAX_VALUE);
}

Top 10 Java Interview Questions on Static keyword

Java Variables and Types of Variables

Posted by: Instanceofjava Posted date: April 14, 2015 / comment : 0 concept and program

Variable:

Variable is a named memory location used to store data temporarily.
During program execution we can modify that data

Limitation of Variable:

It can only store single value at a time.
It means , always it returns latest modified value.

How can a variable be created?

A variable can be created by using data type.
As we have two types of data types we can create two types of variables.
1.Primitive Variable
2.Referenced variable
The difference between primitive and referenced variable is "primitive variable stores data directly , where referenced variables stores reference/address of object, not direct values"

package com.instanceofjava;
class Example
{
int x=10;
int y=20;
}

package instanceofjava;
class Test
{
public int get(){
return 10:
}
public static void main(String [] args){
//primitive variables
int s=50;
int t=get();
//reference variables
String str="a";
String str1=new String("a");
Example e= new Example();
}
}

What is an object?

Technically object means collection of all non static variables and methods memory locations.
Object is created using new keyword

Defining a variable:

Variable creation with value is called defining a variable
<Accessibility modifier><Modifier><Data type><Variable name>=<Value> ;

package instanceofjava;
public class Demo{
public static void main(String[] args){
public static int x=10;
public static Example e= new Example();
}
}

Declaring a variable:

Variable creation without value is called declaring a variable.
<Accessibility modifier><Modifier><Data type><Variable name>;

package instanceofjava;
public class Demo{
public static void main(String[] args){
public static int a;
public static Example e;
}
}

Initializing/Assigning a variable:

Storing a value in a variable at the time of its creation is called initializing a variable.
Storing a value in a variable after its creation is called assigning a value to a variable.
<Variable_Name>=<Value>;

package instanceofjava;
public class Demo{
public static void main(String[] args){
//declaring a variable
int a;
int x;
//assigning a variable
a=20;
x=10;
// re initialization/ re assignment
a=30;
x=20;
}
}

Calling a variable:

Reading a value from a variable is called calling a variable.

package instanceofjava;
public class Demo{
public static void main(String[] args){
int x=10;
//calling x variable for printing
System.out.println(x);
// calling x variable for initializing y
int y=x;
}
}

Types of Variables:

Local
Static
Non static
Final
Transient
Volatile

1.Local Variables:

The variables created inside a method or block are called local variables.

Rules:

While working with local variables , we must follow below 3 rules.

Rule #1:

Local variables can not be accessed from another method. Because its scope is restricted only within its method.
Also we can not guarantee that variable creation , because that method may or may not be called. It leads to compile time Exception : can not find symbol.

Example program:

package com.instanceofjava;
class test
{
public void show(){
System.out.println("a:"+a); Compile time error: can not find symbol a.
}
public static void main(String [] args){
int a=10;
System.out.println("a:"+a);
}
}

Rule #2:

Local variable should not be accessed without initialization.

Example program:

package com.instanceofjava;
class test
{
public static void main(String [] args){
int a=10;
int b;
System.out.println("a:"+a);
System.out.println("b:"+b);//Error
// Above statement throws Compile time Error: variable b might not have been initialized
b=20;
System.out.println("b:"+b);
}
}

Rule #3:

Local variable must be accessed only after its creation statement. because method execution is sequential execution from top to bottom. If we access before its creation statement it leads compile time Error : Can not find symbol.

Example program:

package com.instanceofjava;
class test
{
static void show(){
System.out.println("a:"+a);// Compile time Error
int a;
System.out.println("a:"+a); // Compile time Error
a=10
System.out.println("a:"+a);
}
}

2. Static variables :

Static variables gets life when class is loaded.

It is destroyed either if class is unloaded from JVM or JVM is destroyed.
Its scope is throughout the class it means where class is available there static variable is available provided it is public.

Example program:

package com.instanceofjava;
class test
{
static int a=10;
public static void show(){
System.out.println("a:"+a);
}
public static void main(String [] args){
System.out.println("a:"+a);
}
}

3. Non Static variables:

Non static variable gets life when object is created. It is destroyed when object is destroyed.
Object is destroyed when it is unreferenced.
Its scope is the scope of the object, object is available only if its referenced variable is available

Example program:

package com.instanceofjava;
class test
{
int a=10;
public void show(){
test t= new test();
System.out.println("a:"+t.a);
}
public static void main(String [] args){
test t= new test();
System.out.println("a:"+t.a);
}
}

4.Final variables:

The class level or local variable that has final keyword in its definition is called final variable.

Rule:

Once it is initialized by developer its value can not be changed. If we try to change its value it leads to Compile tile error.

Example program:

package com.instanceofjava;
class test
{
static final int a=10;
static final int b=20;
public static void main(String [] args){
a=20;//Error : variable might be already have been assigned
b=30; //Error : variable might be already have been assigned
}
}

5. Transient variable:

The class level variable that has transient keyword in its definition is called transient variable.

Rule:

Local variable can not be declared as transient.
It leads to Compile time error: Illegal start expression

Example program:

package com.instanceofjava;
class test
{
static transient int a=10;
static transient int b=20;
public static void main(String [] args){
transient int x=10; // compile time error : illegal start expression
}
}

We declare variable as transient to tell to JVM that we do not want to store variable value in a file in object serialization. Since local variable is not part of object , declaring it as transient is illegal.
Refer IOStreams for more details

6.Volatile Variable:

The class level variable that has volatile keyword in its definition.

Rule:

Local variable can not be declared as transient.
It leads to Compile time error: Illegal start expression

Example program:

package com.instanceofjava;
class test
{
static volatile int a=10;
volatile int b=20;
public static void main(String [] args){
volatile int x=10; // compile time error : illegal start expression
}
}

We declare variable as volatile to tell to JVM that we do not want to modify variable value concurrently by multiple threads.
If we declare variable as volatile multiple threads are allowed to change its value in sequence one after another one.

You might like:

Top 15 Garbage Collection Interview Questions

Top 50 Java Questions everybody should know

Top 25 Programs asked in interviews

Top 25 Core Java Interview Questions

Accessibility modifiers examples

Posted by: Instanceofjava Posted date: March 09, 2015 / comment : 0 concept and program

The keywords which define accessibility permissions are called accessibility modifiers.
Java supports four accessibility modifiers to define accessibility permissions at different levels.

Accessibility modifier keywords:

1.private

2.protected

3.public

4.default(no keyword)

1.private:

The class members which have private keyword in its creation statement are called private members. Those members are only accessible within that class.
If we declare any variable or method with private accessibility modifier then those variables and methods are accessible only within that class , not accessible out side the class.

private variable are accessible within the class :

package com.instanceofjava;
public class PrivateDemo {
private String first_name;
private String last_name;
void show(){
System.out.println("First Name:="+first_name);
System.out.println("Last Name:="+last_name);
}
public static void main(String[] args) {
PrivateDemo obj= new PrivateDemo ();
obj.first_name="James";
obj.last_name="Goosling";
obj.show();
}
}

Output:

First Name:=James
Last Name:=Goosling

private variable are not accessible out side the class :

package com.instanceofjava;
public class PrivateDemo {
private String first_name;
private String last_name;
void show(){
System.out.println("First Name:="+first_name);
System.out.println("Last Name:="+last_name);
}
public static void main(String[] args) {
PrivateDemo obj= new PrivateDemo ();
obj.first_name="James";
obj.last_name="Goosling";
}
}

package instanceofjava;
class Demo {
public static void main(String[] args){
PrivateDemo obj= new PrivateDemo ();
obj.first_name="James"; // ERROR: The field PrivateDemo.first_name is not visible
}
}

private methods are accessible within the class :

package com.instanceofjava;
public class PrivateDemo {
private String first_name;
private String last_name;
private void show(){
System.out.println("First Name:="+first_name);
System.out.println("Last Name:="+last_name);
}
public static void main(String[] args) {
PrivateDemo obj= new PrivateDemo ();
obj.first_name="James";
obj.last_name="Goosling";
obj.show();
}
}

Output:

First Name:=James
Last Name:=Goosling

private variable are not accessible out side the class :

package com.instanceofjava;
public class PrivateDemo {
private String first_name;
private String last_name;
void show(){
System.out.println("First Name:="+first_name);
System.out.println("Last Name:="+last_name);
}
public static void main(String[] args) {
PrivateDemo obj= new PrivateDemo ();
obj.first_name="James";
obj.last_name="Goosling";
}
}

package instanceofjava;
class Demo {
public static void main(String[] args){
PrivateDemo obj= new PrivateDemo ();
obj.add(); // ERROR: The method add() from the type PrivateDemo is not visible
}
}

private variables and methods are accessible inside that class only. If we declare any variable or method as private , not accessible outside the class.

2.protected

The class members which have protected keyword in its creation statements are called protected members. Those members can be accessible with in package from all classes, but from out side package only in subclass that too using subclass name or its object.
protected variables accessible inside the package anywhere. Outside package accessible only in sub classes.

Same package anywhere:

package com.instanceofjava;
public class ProtectedDemo {
protected int a;
protected int b;
protected void show(){
System.out.println("a="+a);
System.out.println("b="+b);
}
public static void main(String[] args) {
ProtectedDemo obj= new ProtectedDemo ();
obj.a=12;
obj.b=13;
obj.show();
}
}

Output:

a=12
b=13

Different package subclass:

package com.accesiblitymodifiers;
public class Sample extends ProtectedDemo {
public static void main(String[] args) {
Sample obj= new Sample();
obj.a=12;
obj.b=13;
obj.show();
}
}

Output:

a=12
b=13

3.public

If we declare any variable or method with public access specifier then those members will be accessible to everywhere.

package com.instanceofjava;
public class PublicDemo {
public int x;
public int y;
public void show(){
System.out.println("x="+x);
System.out.println("y="+y);
}
public static void main(String[] args) {
PublicDemo obj= new PublicDemo ();
obj.x=1;
obj.y=2;
obj.show();
}
}

Output:

4.default

If we declare any member with no keyword those members are called default members.
default members are accessible to package level.
Means we can access anywhere in same package but we can not access in out side the package under any condition.
So default will acts as public inside package and private out side the package.

Java data types with examples

Posted by: Instanceofjava Posted date: March 09, 2015 / comment : 0 concept and program

In java mainly we have two types of data types.

Primitive data types or Fundamental data types.
Referenced data types or Derived data types.

1.Primitive Data types

1.byte

package com.instanceofjava;
public class ByteDemo {
public static void main(String[] args) {
byte a=10; // a is a variable of type byte holding the value 1;
byte b=20;// b is a variable of type byte holding the value 2;
byte c= (byte)(a+b);
System.out.println(c);
}
}

Output:

2.short

package com.instanceofjava;
public class ShortDemo {
public static void main(String[] args) {
short a=1;
short b=2;
short c= (short)(a+b);
System.out.println(c);
}
}

Output:

3.int

package com.instanceofjava;
public class IntDemo {
public static void main(String[] args) {
int a=10; // a is a variable of type integer holding the value 10;
int b=20;// b is a variable of type integer holding the value 20;
int c= a+b;
System.out.println(c);
}
}

Output:

4.long

package com.instanceofjava;
public class LongDemo {
public static void main(String[] args) {
long a=1234567890;
long b=1234567890;
long c= a+b;
System.out.println(c);
}
}

Output:

2469135780

5.float

package com.instanceofjava;
public class FloatDemo {
public static void main(String[] args) {
float a=1234567.8f;
float b=1234567.8f;
float c= a+b;
System.out.println(c);
}
}

Output:

2469135.5

7.double

package com.instanceofjava;
public class DoubleDemo {
public static void main(String[] args) {
double a=1234567910112181314151634444422233334491.1d;
double b=1234567910112181314151634444422233334491.8d;
double c= a+b;
System.out.println(c);
}
}

Output:

2.4691358202243627E39

8.char

package com.instanceofjava;
public class CharDemo {
public static void main(String[] args) {
char a='A';
char b= 'B';
System.out.println(a);
System.out.println(b);
System.out.println(a+b);
}
}

Output:

9.boolean

package com.instanceofjava;
public class BooleanDemo {
public static void main(String[] args) {
boolean a=true;
boolean b= false;
System.out.println(a);
System.out.println(b);
}
}

Output:

true
false

1.Referenced Data types

1.class

package com.instanceofjava;
public class Sample{
int a,b;
void add(){
System.out.println(a+b);
}
public static void main(String[] args) {
Sample obj= new Sample();
obj.a=10;
obj.b=12;
obj.add();
}
}

Output:

2.Array

package com.instanceofjava;
public class ArrayDemo {
public static void main(String[] args) {
int a[]={1,2,3,4,5,6};
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}

Output:

Constructors in java

Posted by: Instanceofjava Posted date: March 08, 2015 / comment : 0 concept and program

Constructors will be executed when the object is created.
Constructors should have same name of class name.
Executed once per object.
Basically used to assign instance variables
We can overload constructors.
We can call super class constructor form sub class constructor.

package instanceofjava;
class A{
A(){
}
}
}

while creating object constructor will be executed so we can assign instance variables to some default values.

package instanceofjava;
class A{
int a,b
A(int x, int y){
a=x;
b=y;
}
public static void main(String[] args){
A a=new A(10,20);
}
}

Types of constructors:

There are two types of constructors
Default constructors
Parameterized constructor.

Default constructor:

Default constructor will not have any arguments.
If we not defined any constructor in our class. JVM automatically defines a default constructor to our class.

package instanceofjava;
class Sample{
int a,b
Sample(){
a=37;
b=46;
}
public static void main(String[] args){
Sample obj=new Sample();
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Parameterized constructor

package instanceofjava;
class Sample{
int a,b
Sample(int x, int y){
a=x;
b=y;
}
public static void main(String[] args){
Sample obj=new Sample(37,46);
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Constructor overloading:

package instanceofjava;
class Sample{
int a,b
Sample(){
this(1,2);
System.out.println("Default constructor");
}
Sample(int x , int y){
this(1,2,3);
a=x;
b=y;
System.out.println("Two argument constructor");
}
Sample(int a , int b,int c){
System.out.println("Three argument constructor")
}
public static void main(String[] args){
Sample obj=new Sample();
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Three argument constructor
Two argument constructor
Default argument constructor
1
2

This and Super Keywords

Posted by: Instanceofjava Posted date: March 08, 2015 / comment : 0 concept and program

this keyword used to store current object reference.
super keyword used to store super class reference in subclass object.

this keyword:

Predefined instance variable to hold current object reference.

It must used explicitly if non-static variable and local variable name is same.

Output:

Without this keyword if variable names are same we can not assign instance variables so this problem will solve by using this keyword

package com.instanceofjava;
public class ThisDemo {
int a, b;
ThisDemo(int a, int b){
this.a=a;
this.b=b;
}
public static void main(String[] args){
ThisDemo obj= new ThisDemo(1,2);
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Used to invoke current class constructor:

package com.instanceofjava;
public class ThisDemo {
int a, b;
ThisDemo(){
System.out.println("Default constructor called");
}
ThisDemo(int a, int b){
this();
this.a=a;
this.b=b;
}
public static void main(String[] args){
ThisDemo obj= new ThisDemo(1,2);
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Default constructor called
1
2

Used to call current class method:

package com.instanceofjava;
public class Sample{
int a, b;
Sample(int a, int b){
this.a=a;
this.b=b;
}
void show(){
System.out.println("Show() method called");
}
void print(){
this.show();
System.out.println(obj.a);
System.out.println(obj.b);
}
public static void main(String[] args){
Sample obj= new Sample(1,2);
obj.print()
}
}

Output:

Show() method called
1
2

super keyword:

Predefined instance variable used to hold super class object reference through sub class object.

Super keyword interview questions java

Used to call super class constructor:

package com.instanceofjava;
public class A{
int a, b;
A(int a, int b){
a=a;
b=b;
System.out.println("super class constructor called");
}
}

package com.instanceofjava;
public class B extends A{
int a, b;
A(int a, int b){
super(a,b);
a=a;
b=b;
}
public static void main(String[] args){
B obj= new B(1,2);
}
}
}

Output:

super class constructor called
1
2

Used to call super class methods from subclass:

package com.instanceofjava;
public class A{
int a, b;
A(int a, int b){
a=a;
b=b;
System.out.println("super class constructor called");
}
void add(){
System.out.println("super class method called");
}
}

package com.instanceofjava;
public class B extends A{
int a, b;
A(int a, int b){
super(a,b);
a=a;
b=b;
}
void print(){
super.add();
System.out.println(this.a);
System.out.println(this.b);
}
public static void main(String[] args){
B obj= new B(1,2);
obj.print();
}
}
}

Output:

super class method called
1
2

Abstraction

Posted by: Instanceofjava Posted date: March 08, 2015 / comment : 2 concept and program

Abstraction is fundamental principle of modeling. A system model is created at different levels, starting at the higher levels and adding more levels with more details as more is understood about the system. When complete, the model can be viewed at several levels.
So abstraction is about,

Looking only at the information that is relevant at that time
Hiding details so as not to confuse the bigger picture

Abstraction is a process of developing a class by hiding or removing non essential details relevant to user. here non essential details means method body and logic
Basically Abstraction provides a contract between a service provider and clients.
we can achieve this by using abstract class

package Abstraction;
public abstract class AbstractDemo {
abstract void add(); // abstract method
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

Abstract class can not be instantiated directly.
Means we can not create object for abstract class directly

package Abstraction;
public abstract class AbstractDemo {
abstract void add(); // abstract method
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
public static void main(String[] args){
AbstractDemo obj= new AbstractDemo();
// ERROR: Cannot instantiate the type AbstractDemo
}
}

Can we declare abstract methods as static?

package Abstraction;
public abstract class AbstractDemo {
static abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

No, we are not allowed to declare method as static . It leads to compile time error.

Can we declare abstract methods as final?

package Abstraction;
public abstract class AbstractDemo {
final abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

No, we are not allowed to declare method as static . It leads to compile time error.
Because it should be inherited to sub class.

Can we declare abstract methods as private?

package Abstraction;
public abstract class AbstractDemo {
final abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

No, we are not allowed to declare method as static . It leads to compile time error.
Because it should be inherited to sub class.

Legal modifiers allowed in combination with abstract

1.native

package Abstraction;
public abstract class AbstractDemo {
native abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

2.protected

package Abstraction;
public abstract class AbstractDemo {
protected abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

3.public

package Abstraction;
public abstract class AbstractDemo {
public abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

4.default

package Abstraction;
public abstract class AbstractDemo {
abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

How it works:

package Abstraction;
public abstract class AbstractDemo {
abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

package Abstraction;
public abstract class Example extends AbstractDemo {
abstract void add(){
System.out.println("this is implemented method in sub class");
}
}

Subscribe to: Comments ( Atom )