InstanceOfJava

What is the difference between equals() method and == operator

Posted by: Instanceofjava Posted date: December 24, 2014 / comment : 0 Core java Interview Questions

== operator:

== operator used to compare objects references.
used to compare data of primitive data types
if we are comparing two objects using "==" operator if reference of both are same then it will returns true otherwise returns false.
obj1==obj2;
If we are comparing primitive data type variables then it compares data of those two variables
Ex: int a=12; int b=12; if(a==b) returns true

Comparing primitive values:

package com.instanceofjava;
Class Demo{
public static void main (String args[]) {
int a=12;
int b=13;
int c=12;
if(a==b){
System.out.println("a and b are equal");
}
if(b==c){
System.out.println("a and b are equal");
}
}
}

Comparing Objects:

package com.instanceofjavaforus;
Class Demo{
public static void main (String args[]) {
Demo obj1= new Demo();
Demo obj2=new Demo();
if(obj1==obj2){ // here both are two different objects(memory allocation wise);
System.out.println("obj1 and obj2 are referring to same address");
}else{
System.out.println("obj1 and obj2 are referring to different address");
}
}
}

Comparing String Objects:

package com.instanceofjava;
Class ComapreStringDemo{
public static void main (String args[]) {
String s1=new String("abc");
String s2=new String("abc");
if(s1==s2){ // here it returns false
System.out.println("obj1 and obj2 are referring to same address");
}else{
System.out.println("obj1 and obj2 are referring to different address");
}
}
}

Comparing String Literals:

If we declared two string literals with same data then those will refer same reference.
means if we create any object using string literal then it will be created in string pool
then if we are created another literal with same data then it wont create another object rather refers same object in pool.
so if compare two string literals with same data using "==" operator then it returns true.

package com.instanceofjava;
Class ComapreStringLiteralDemo{
public static void main (String args[]) {
String s1="abc";
String s2="abc";
if(s1==s2){ // here it returns true
System.out.println("obj1 and obj2 are referring to same address");
}else{
System.out.println("obj1 and obj2 are referring to different address");
}
}
}

equals() method:

equals() method defined in "object" class.
By default equals methods behaves like "==" operator when comparing objects.
By default equals() method compares references of objects.
But All wrapper classes and String class overriding this equals method and comparing data .
Means in String class and in All wrapper classes this equals() methods is overridden so that to compare data of those class objects.

Comparing String Objects:

package com.instanceofjava;
Class ComapreStringDemo{
public static void main (String args[]) {
String s1=new String("abc");
String s2=new String("abc");
if(s1.equals(s2)){ // here it returns true
System.out.println(" data present in obj1 and obj2 is same");
}else{
System.out.println(" data present in obj1 and obj2 is different");
}
}
}

Comparing custom objects:

If we want to compare custom objects means our own objects data.
Then we need to override equals method and in that we need to compare data.

package com.instanceofjavaforus;

public class Patient {
   String name;
   Patient(String name){
       this.name=name;
   }
      public boolean equals(Patient obj){

       if(this.name.equals(obj)){
           return true;
       }else{
           return false;
       }
   }
       public static void main(){
        Patient obj1= new Patient("sam");

        Patient obj2= new Patient("sam");

        System.out.println(obj1.equals(obj2)); //returns true
    }

}

Important points to note about equals() and "==":

"==" used to compare data for primitive data type variables .
"==" operator compares objects references
By default equals() method behaves like "==" operator for objects means compares objects references.
All wrapper classes and String class overriding this equals() method and compares data of two objects. if same returns true.(when ever we overrides equals() method we need to override hashcode() method too and if two objects on equal method same then both should have same hashcode).
And in equals() method in string class logic includes "==" operator too.

package com.instanceofjava;
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}

Difference between throw and throws in java

Posted by: Instanceofjava Posted date: December 23, 2014 / comment : 0 Java SE

Throw:

throw keyword used to throw user defined exceptions.(we can throw predefined exception too)
If we are having our own validations in our code we can use this throw keyword.
For Ex: BookNotFoundException, InvalidAgeException (user defined)

//Custom exception
package com.instanceofjavaforus;
public class InvalidAgeException extends Exception {
InvaidAgeException(String msg){
super(msg);
}
}

package com.instanceofjavaforus;
public class ThrowDemo {
public boolean isValidForVote(int age){
try{
if(age<18){
throw new InvalidAgeException ("Invalid age for voting");
}
}catch(Exception e){
System.out.println(e);
}
return false;
}
public static void main(String agrs[]){
ThrowDemo obj= new ThrowDemo();
obj.isValidForVote(17);
}
}

We can throw predefined exceptions also

package com.instanceofjavaforus;
public class ThrowDemo {
public void method(){
try{
throw new NullPointerException("Invalid age for voting");
}
}catch(Exception e){
System.out.println(e);
}
}
public static void main(String agrs[]){
ThrowDemo obj= new ThrowDemo();
obj.method();
}
}

Like this we can throw checked exceptions and unchecked exceptions also. But throw keyword is mainly used to throw used defined exceptions / custom exceptions.

Throws:

The functionality of throws keyword is only to explicitly to mention that the method is proven transfer un handled exceptions to the calling place.

package com.instanceofjavaforus;
public class ThrowSDemo {
public void method(int a,int b) Throws ArithmeticException{
inc c= a/b;
}
public static void main(String agrs[]){
ThrowDemo obj= new ThrowDemo();
try{
obj.method(1,0);
}catch(Exception e){
System.out.println(e);
}
}
}

Uses of throws keyword:

Using throws keyword we can explicitly provide the information about unhand-led exceptions of the method to the end user, Java compiler, JVM.
Using throws keyword we can avoid try-catch with respect to the statements which are proven to generate checked exceptions.
It us highly recommended not to avoid try-catch with respect to the statements which are proven to generate exceptions in main method using throws keyword to the main() method.

JDBC

Posted by: Instanceofjava Posted date: December 23, 2014 / comment : 0 JDBC

JDBC:

The JDBC ( Java Database Connectivity) API defines interfaces and classes for writing database applications in Java by making database connections.
Using JDBC you can connect to the database and execute any type of statements related relational database.
JDBC is a Java API for executing SQL statements and supports basic SQL functionality.

JDBC Architecture:

http://instanceofjavaforus.blogspot.in/

Java application calls the JDBC API. JDBC loads a driver which connects to the database.

Connectivity Steps to JDBC:

5 Steps to connect java Application with the database using JDBC.They are:

Register the driver class
Creating Connection
Creating Statement
Execting Queries
Closing Connection

Register the driver class:

The forName() of class is used to register the driver class.Using this class is used load the class dynamically.

try {

Class.forName(com.mysql.jdbc.Driver”); //Or any other driver

}

catch(Exception x){

System.out.println( “Unable to load the driver class!” );

}

Creating the Connection:

DriverManager is the backbone of JDBC architecture. DriverManager class manages the JDBC drivers that are installed on the system.

Its getConnection() method of Driver Manager class is used to establish a connection to a database. It uses a username, password, and a jdbc url to establish a connection to

the database and returns a connection object.

try{

Connection dbConnection=DriverManager.getConnection(url,”loginName”,”Password”)

}

catch( SQLException x ){

System.out.println( “Couldn’t get connection!” );

}

Creating Statement:

Once a connection is established we can interact with the database. Connection interface defines methods for interacting with the database via the established connection. Statement

A statement object is used to send and execute SQL statements to a database.

statement = dbConnection.createStatement();

Three kinds of Statements:

Statement

Prepared Statement

Callable Statement

Statement:

Execute simple sql queries without parameters.

Statement createStatement().

Prepared Statement:

Execute precompiled sql queries with or without parameters.

PreparedStatement prepareStatement(String sql).

Callable Statement:

Execute a call to a database stored procedure.

CallableStatement prepareCall(String sql)

Executing Queries:

Statement interface defines methods that are used to interact with database and execution of SQL statements.

The Statement class has three methods:

executeQuery()

executeUpdate()

execute().

executeQuery():

For a SELECT statement, the method to use is executeQuery .

executeUpdate():

For statements that create or modify tables, the method to use is executeUpdate.
statements and are executed with the method executeUpdate.

execute():

execute() executes an SQL statement that is written as String object.

Connection Close():

This method is used to close the connection.

con.close();

Syntax:

public void close() throws SQLException.

Difference between enumeration and iterator and listiterator?

Posted by: Instanceofjava Posted date: December 22, 2014 / comment : 0 Collections

Enumeration:

Enumeration interface implemented in java 1.2 version.So Enumeration is legacy interface.
Enumeration uses elements() method.
Enumeration can traverse in forward direction only.
Enumeration having methods like hasMoreElement(),nextElement().

Program:

package com.instanceofjavaforus;

import java.util.Enumeration;

import java.util.Vector;

public class EnumerationDemo {

public static void main(String[] args) {

Vector vector=new Vector();

vector.add("indhu");

vector.add("sindhu");

vector.add("swathi");

vector.add(null);

Enumeration en = vector.elements();

while(en.hasMoreElements()){

System.out.println(en.nextElement());

}

Output:

indhu

sindhu

swathi

null

Iterator:

Iterator is implemented on all Java collection classes.
Iterator uses iterator() method.
Iterator can traverse in forward direction only.
Iterator having methods like hasNext(), next(), remove().

Program:

package com.instanceofjavaforus;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.TreeMap;

public class IteratorDemo{

public static void main(String[] args) {

TreeMap treeMap=new TreeMap();

treeMap.put("g", "indhu");

treeMap.put("d", "sindhu");

treeMap.put("3", "swathi");

treeMap.put("d", "sindhu");

if(!treeMap.isEmpty()){

Iterator it=treeMap.entrySet().iterator();

while(it.hasNext()){

Map.Entry obj=(Entry) it.next();

System.out.println(obj.getValue());

}

Output:

swathi

sindhu

indhu

ListIterator:

ListIterator is implemented only for List type classes
ListIterator uses listIterator() method.
ListIterator can traverse in forward and backward directions.
ListIterator having methods like
hasNext()
next()
previous()
hasPrevious()
remove()
nextIndex()
previousIndex().

Program:

package com.instanceofjavaforus;

import java.util.ArrayList;

import java.util.ListIterator;

public class ListIteratorDemo{

public static void main(String[] args) {

ArrayList arrayList=new ArrayList();

arrayList.add("indhu");

arrayList.add("sindhu");

arrayList.add("saidesh");

arrayList.add(null);

ListIterator it=arrayList.listIterator();

while(it.hasNext()){

System.out.println(it.next());

}

Output:

indhu

sindhu

saidesh

null

Why Java does not supports multiple inheritance?

Posted by: Instanceofjava Posted date: December 22, 2014 / comment : 3 Core java Interview Questions , Java SE

Inheritance:

The concept of getting properties of one class object to another class object is known as inheritance.
Here properties means variable and methods.

Types of Inheritance:

Multiple inheritance.
Multilevel inheritance.

Multiple inheritance:

The concept of Getting the properties from multiple class objects to sub class object with same priorities is known as multiple inheritance.
Java Doesn't Support multiple Inheritance.

Diamond problem:

In multiple inheritance there is every chance of multiple properties of multiple objects with the same name available to the sub class object with same priorities leads for the ambiguity.

//Multiple inheritance program
Class A{
}
Class B extends A{
public void show(){
}
}
Class C extends A{
public void show(){
}
}
Class D extends B,C{ // not supported by java leads to syntax error.
}

Why multiple inheritanc eis not possible in java

We have two classes B and c which are inheriting A class properties.
Here Class D inheriting B class and C class So properties present in those classes will be available in java.
But both classes are in same level with same priority.
If we want to use show() method that leads to ambiguity
This is called diamond problem.
Because of multiple inheritance there is chance of the root object getting created more than once.
Always the root object i.e object of object class hast to be created only once.
Because of above mentioned reasons multiple inheritance would not be supported by java.
Thus in java a class can not extend more than one class simultaneously. At most a class can extend only one class.

So these are the reasons that java does not supports multiple inheritance.Even though having this much reasons some people say and we also gets some doubts when we are using interfaces. lets me clear this one also. our immediate question should be.

Is Java supports multiple inheritance using interfaces?

Before that we need to know about interfaces.
Interfaces having fully abstract functionality.
Means methods in interfaces by default public abstract methods so we need to implement these methods in classes which are extending this interface.

/Multiple inheritance program
interface A{
public void show();
}
interface B{
public void display();
}
Class C Implements A,B{
}

Here it seems we are achieving multiple inheritance by using interfaces. but we are not.
Syntactically it seems to multiple inheritance but the actual implementation of multiple inheritance is not there. how can i say that? let me clear

Difference between interfaces and inheritance: in multiple inheritance

Inheritance means getting the properties from one class object to another class object.
Means if any class extending another class then the super class methods can be used in sub classes happily.
But in interfaces the methods in interfaces are fully abstract so we need to provide functionality in our extended class and use it .seems both are opposite right? yes.
That is the reason we can say interfaces are only supports syntactical multiple inheritance which is not implementation of multiple inheritance.

So finally java supports only syntax of multiple inheritance does not supports implementation of multiple inheritance.
Inheritance is like debit and interface is like credit but interface has its own importance in other concepts like server side programming

What is the major change in JAVA 8 regarding interfaces:

Yes from java 8 we can add static methods and defaults methods in interfaces by this we can achieve multiple inheritance.
Java 8 interface static and default methods

5 different places to define Object of a class in java

Posted by: Instanceofjava Posted date: December 18, 2014 / comment : 2 Core java Interview Questions , Java SE

Object of a class can be defined at 5 different places.

Defining object of a class as local to a method or local variable.
Defining object of a class as an instance variable of another class.
Defining object of a class as the parameter of the method.
Defining object of a class as the return data type of the method.
Defining object of a class as the static variable or class variable of another class.

1.Defining object of a class as local to a method or local variable:

package com.instanceofjava;
public class ObjectInsideMethod {
int val;
public int getVal()
{
return val;
}
public void setVal(int val) {
this.val = val;
}
public void createObject(){
ObjectInsideMethod obj=new ObjectInsideMethod();
obj.setVal(10);
System.out.println(obj.getVal());
}
public static void main(String[] args) {
ObjectInsideMethod obj=new ObjectInsideMethod();
obj.createObject();
}
}

2.Defining object of a class as an instance variable of another class:

package instanceofjava;
class sample{
int num;
public void setNum(int num) {
this.num= num;
}
public String getNum() {
return num;
}
}

package com.instanceofjava;
public class ObjectAsInstanceVariable {
Sample sample= new Sample ();
public static void maina(String args[]){
ObjectAsInstanceVariable obj=new ObjectAsInstanceVariable();
obj.sample.setNun(10);
}
}

3.Defining object of a class as the parameter of the method.

package com.instanceofjava;
public class Employee
{
String name;
int id;
String address;
Employee(String name, int id, String address){
this.name=name;
this.id=id;
this.address=address;
}
public boolean comapreEmpids(Employee e){
if(this.id==e.id){
return true;
}
return false;
}
public static void main(String args[]){
Employee empone= new Employee("sai", 1, "hyderabad");
Employee emptwo= new Employee("sai", 2, "Khammam");
boolean check=empone.comapreEmpids(emptwo);
System.out.println(check); //returns false
}
}

4.Defining object of a class as the return data type of the method.

package com.instanceofjava;
public class Singleton
{
static Singleton obj;
private Singleton(){
}
public static Singleton getInstance(){
if(obj!=null){
return obj;
}
else{
obj=new Singleton();
return obj;
}
}
public static void main(String[] args) {
Singleton obj=Singleton.getInstance();
Singleton obj1=Singleton.getInstance();
}
}

5.Defining object of a class as the static variable or class variable of another class

package com.instanceofjavaforus;
public class Sample {
public void diplsyString(String str){
System.out.println(str);
}
}
package com.instanceofjavaforus;
public class TestDemo {
public static Sample sample= new Sample();
public static void main(String args[]){
TestDemo.sample.diplsyString("Hello Hyderabd");
}
}

This scenario used in System.out.println();

You Might Like:

1.What are all the Five different ways to create object in java

2.Java Example program to restrict a class from creating not more than three objects

3.Six different ways to iterate list in java

Subscribe to: Posts ( Atom )