InstanceOfJava

Static Members in java

Posted by: Instanceofjava Posted date: 12:30 PM / 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: 5:40 PM / 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

How Java Technology Change My Life

Posted by: Instanceofjava Posted date: 3:13 PM / 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: 3:29 PM / 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

Top 20 Oops Concepts Interview Questions

Posted by: Unknown Posted date: 11:30 PM / comment : 3 Concept and Interview Questions

1.What are the oops concepts in java?

Oop is an approach that provides a way of modularizing a program by creating partitioned memory area for both data and methods that can be used as template for creating copies of such modules on demand.
The four oops concepts are
Encapsulation
Polymorphism
Inheritance
Abstraction

2. What is encapsulation?

The process of binding the data with related methods known as encapsulation.
Class is the base for encapsulation.
Check here for more points on Encapsulation

3.What is class ?

A class is a specification or blue print or template of an object.
Class is a logical construct , an object has physical reality.
Class is a structure.
Class is a user defined data type in java
Class will acts as base for encapsulation.
Class contains variables and methods.

package com.instanceofjava;
class Demo{
int a,b;
void show(){
}
}

4. What is an object?

Object is instance of class.
Object is dynamic memory allocation of class.
Object is an encapsulated form of all non static variables and non static methods of a particular class.
The process of creating objects out of class is known as instantiation.

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

Output:

a=10
b=20

5. What are the Object Characteristics?

The three key characteristics of Object are
State
Behavior
Identity

State:

Instance variables value is called object state.
An object state will be changed if instance variables value is changed.

Behavior:

Behavior of an object is defined by instance methods.
Behavior of an object is depends on the messages passed to it.
So an object behavior depends on the instance methods.

Identity:

Identity is the hashcode of an object, it is a 32 bit integer number created randomly and assigned to an object by default by JVM.
Developer can also generate hashcode of an object based on the state of that object by overriding hashcode() method of java.lang.Object class.
Then if state is changed , automatically hashcode will be changed.

6.What is Inheritance?

As the name suggests , inheritance means to take something that already made.
One of the most important feature of Object oriented Programming. It is the concept that is used for re usability purpose.
Getting the properties from one class object to another class object.

7. How inheritance implemented in java?

Inheritance can be implemented in JAVA using below two keywords.
1.extends
2.implements
extends is used for developing inheritance between two classes or two interfaces, and implements keyword is used to develop inheritance between interface and class.

package com.instanceofjava;
class A{
}

package com.instanceofjava;
class B extends A{
}

8. What are the types of inheritances?

There are two types of inheritance
1.Multilevel Inheritance
2.Multiple Inheritance

Multilevel Inheritance:

Getting the properties from one class object to another class object level wise with some priority is known as multilevel inheritance.

package com.instanceofjava;
class A{
}
class B extends A{
}
class C extends B{
}

Multiple Inheritance:

The concept of getting multiple class objects to single class object is known as multiple inheritance. multiple inheritance is not supported by java
Check here for Why java does not supports multiple inheritance

9. What is polymorphism?

Defining multiple methods with same name,

Static polymorphism:

Defining multiple methods with same name with different parameters.
Is also known as method overloading.

package com.instanceofjava;
class Demo{
void add(){
}
void add(int a, int b){
}
void add(float a, float b){
}
public static void main(String [] args){
Demo obj= new Demo();
obj.add();
obj.add(1,2);
obj.add(1.2f,1.4f);
}
}

Dynamic Polymorphism:

Defining multiple methods with same signature in super class and sub class.
The sub most object method will be executed always.

what is the difference between method overloading and method overriding?

10. Similarities and differences between this and super keywords?

this:

This is a keyword used to store current object reference.
It must be used explicitly if non -static variable and local variables name is same.
System.out.print(this); works fine

super:

Super is a keyword used to store super class non -static members reference in sub class object.
used to separate super class and sub class members if both have same name.
System.out.println(super); compilation Error

Check here for more differences between this and super

11.Top 10 interview Questions on Method overriding

12.Top 15 interview programming questions on abstract classes

13.Top 10 interview Question on interfaces

14.Java Quiz

15. Basic Method overloading interview questions in java

16. Super keyword interview Questions in java

17.Top 10 java Interview questions on final keyword

18. Top 10 basic interview questions and answers on this keyword

19. Top 20 java interview questions on constructors

20. 19 Oops concepts explanation with example programs

For more interview programs : Top 60 Java Programs asked in interviews
Read Also:

1. Top 15 Garbage Collection Interview Questions

2. Top 10 Oops Concepts Interview Questions

3. Top 15 Java Interview Questions on Constructors

4. Top 10 Inheritance Interview Questions

5. Interview Programs on Strings

6. 10 Interesting Core Java Interview Coding Questions and Answers

7. Top 20 Basic Java Interview Questions for Frehsers

8. Top 10 interview Question on Static keyword.

9.Top 20 Java interview Questions on Increment and Decrement operators

10.Top 10 Interview Questions on main() method

11. Top 12 Java Experienced interview Programming Questions on Strings

12.Pattern Programs in java Part-1

13.Pattern Programs in java Part-2

14.Pattern Programs in java Part-3

Subscribe to: Posts ( Atom )

Static Members in java

Types of Static Members:

1.Static Variable:

Life time and scope:

Duplicate Variables:

Shadowing:

Local preference:

Order of execution of static variables and main method:

Final Static Variables:

Java Variables and Types of Variables

Variable:

Limitation of Variable:

How can a variable be created?

What is an object?

Defining a variable:

Declaring a variable:

Initializing/Assigning a variable:

Calling a variable:

Types of Variables:

1.Local Variables:

Rules:

Rule #1:

Rule #2:

Rule #3:

2. Static variables :

3. Non Static variables:

4.Final variables:

Rule:

5. Transient variable:

Rule:

6.Volatile Variable:

Rule:

Top 20 Java Interview Questions on Constructors

1. Define Constructor?

2.What are the Rules in defining a constructor?

3. Can we define a method with same name of class?

4.If we place return type in constructor prototype will it leads to Error?

5. How compiler and JVM can differentiate constructor and method definitions of both have same class name?

6. How compiler and JVM can differentiate constructor and method invocations of both have same class name?

7.Why return type is not allowed for constructor?

8.Why constructor name is same as class name?

9.Can we declare constructor as private?

10.Is Constructor definition is mandatory in class?

11. Why compiler given constructor is called as default constructor?

12. what is default accessibility modifier of default constructor?

13.When compiler provides default constructor?

14.When developer must provide constructor explicitly?

15.If class has explicit constructor , will it has default constructor?

How Java Technology Change My Life

1. Get Started Quickly:

2.Write less code

3.Write Better code:

4.Develop programs more quickly:

5.Avoid platform dependencies:

6.Write once run anywhere:

7.Distribute software more easily:

What can Java Technology Do?

Development Tools:

Application Programming Interface(API):

Deployment Technologies:

User Interface Tool-kits:

Integration Libraries:

Static import In java

Static import:

Without Static Import:

Using Static import:

static imports in java 1.5 examples:

Importing Math class:

Importing System class:

Importing User defined classes:

Arrays and Collections:

Advantages and Disadvantages of Static imports in java:

Top 20 Oops Concepts Interview Questions

1.What are the oops concepts in java?

2. What is encapsulation?

3.What is class ?

4. What is an object?

5. What are the Object Characteristics?

State:

Behavior: