Share Your knowledge

Exceptions in Java

2012-08-29T09:48:00.008-07:00

Exception is an abnormal flow in the execution of program which a method can't handle the execution itself . This situation is called as an exception .

Come to Java
There are two types of exceptions in java

Checked exceptions:
checked exceptions are also known as compile time exceptions as they are identified during compile time of the program.Exception and all the subclasses of Exception class are checked exceptions.

Example : FileNotFoundException .

Unchecked exceptions:
Unchecked Exceptions are also known as runtime exceptions as they are identified during the runtime of the program. class Runtime Exception and all the subclasses of Runtime Exception are unchecked Exceptions.

Examples : NullPointerException , ArrayIndexOutofBoundException.

Error :
Errors should never be created, thrown, caught, or repaired. They are usually beyond the scope of your application code such as 'out of memory'. Even if you caught an out of memory error, you wouldn't likely be in a better place than the system garbage collector to fix this (and you'd have to fix it while allocating no new memory) so its better to let the system crash and repair the root cause.

Errors are :
Are always unchecked
Usually indicate a system error or a problem with a low-level resource
Should be handled at the system level, if possible

Difference between error and Exception

2012-08-29T09:44:00.001-07:00

Exceptions are things you can create/throw yourself or that might be thrown because of an obvious run-time error such as trying to access a null object or reading an array out of bounds. They can also be caught and repaired by a developer.

Errors should never be created, thrown, caught, or repaired. They are usually beyond the scope of your application code such as 'out of memory'. Even if you caught an out of memory error, you wouldn't likely be in a better place than the system garbage collector to fix this (and you'd have to fix it while allocating no new memory) so its better to let the system crash and repair the root cause.

Exception HIerarchy in Java

2012-08-29T09:38:00.003-07:00

Exception subclasses represent errors that a program can reasonably recover from. Except for RuntimeException and its subclasses (see below), they generally represent errors that a program will expect to occur in the normal course of duty: for example, network connection errors and filing system errors.
Error subclasses represent "serious" errors that a program generally shouldn't expect to catch and recover from. These include conditions such as an expected class file being missing, or an OutOfMemoryError.
RuntimeException is a further subclass of Exception. RuntimeException and its subclasses are slightly different: they represent exceptions that a program shouldn't generally expect to occur, but could potentially recover from. They represent what are likely to beprogramming errors rather than errors due to invalid user input or a badly configured environment.

JDBC Sample Program

2012-08-29T09:36:00.000-07:00

JDBCSample.java

import java.sql.*

public class JDBCSample {

public static void main( String args[]) {

String connectionURL = "jdbc:postgresql://localhost:5432/movies;user=java;password=samples";
// Change the connection string according to your db, ip, username and password

try {

// Load the Driver class.
Class.forName("org.postgresql.Driver");
// If you are using any other database then load the right driver here.

//Create the connection using the static getConnection method
Connection con = DriverManager.getConnection (connectionURL);

//Create a Statement class to execute the SQL statement
Statement stmt = con.createStatement();

//Execute the SQL statement and get the results in a Resultset
ResultSet rs = stmd.executeQuery("select moviename, releasedate from movies");

// Iterate through the ResultSet, displaying two values
// for each row using the getString method

while (rs.next())
System.out.println("Name= " + rs.getString("moviename") + " Date= " + rs.getString("releasedate");
}
catch (SQLException e) {
e.printStackTrace();
}
catch (Exception e) {
e.printStackTrace();
}
finally {
// Close the connection
con.close();
}
}
}

Difference between Statement , Prepared Statement and Callable statement .

2012-08-29T09:34:00.000-07:00

Statement:

Statement is used to execute normal SQLs , it won't take any parameters. Generally preferable for DDL statements and normal SQLs without any parameters.

Statement st=conn.createStatement();
st.execute("create table tableA (columnA int not null, columnB varchar(255) )");

Prepared Statement:

Prepared statement is used to execute dynamic SQLs with parameters, it extends Statement interface.
If you are executing the same query multiple times, its preferable to use to the prepared statement , since it pre-compiles the statements

PreparedStatement prepStmt= conn.prepareStatement("update tableA set column1=? where column2=?");

prepStmt.setString(1, "test");   

prepStmt.setInt(2, 444);

Callable Statement: Execute a call to a database stored procedure. it extends statement interface . It allows the user to send parameters to procedure and retrieve the data from procedure.

CallableStatement cStmt= conn.prepareCall("call procA(?,?,?)")
cStmt.setString(1,"test");
cStmt.setInt(2,444);
cStmt.registerOutParameter(3);
cStmt.execute();

Collections Framework in Java

2012-08-23T10:49:00.001-07:00

Collections in Java :
The Java collections framework standardizes the way in which groups of objects are handled by your programs.

The Collection Interfaces:
The collections framework defines several interfaces. This section provides an overview of each interface:

Interface Description
Collection Enables you to work with groups of objects; it is at the top of the collections hierarchy
List Extends Collection to handle sequences (lists of objects)
Set Extends Collection to handle sets, which must contain unique elements
SortedSet Extends Set to handle sorted sets

The Collection Classes:
AbstractCollection Implements most of the Collection interface.
AbstractList Extends AbstractCollection and implements most of the List interface.
AbstractSequentialList Extends AbstractList for use by a collection that uses sequential rather than random access of its elements.
LinkedList Implements a linked list by extending AbstractSequentialList.
ArrayList Implements a dynamic array by extending AbstractList.
SortedSet subSet(Object start, Object end) Returns a SortedSet that includes those elements between start and end–1. Elements in the returned collection are also referenced by the invoking object.
SortedSet tailSet(Object start) Returns a SortedSet that contains those elements greater than or equal to start that are contained in the sorted set. Elements in the returned

set are also referenced by the invoking object.

AbstractSet Extends AbstractCollection and implements most of the Set interface.
HashSet Extends AbstractSet for use with a hash table.
LinkedHashSet Extends HashSet to allow insertion-order iterations.
TreeSet Implements a set stored in a tree. Extends AbstractSet.

Introduction to OOPS Concepts

2012-08-22T10:43:00.000-07:00

Class : is the real world entity . It is the central point of OOP and that contains data and codes with behavior. In Java everything happens within class and it describes a set of objects with common behavior. The class definition describes all the properties, behavior, and identity of objects present within that class.

Object : Object is an instance of a class . Objects are the basic unit of object orientation with behavior, identity. As we mentioned above, these are part of a class but are not the same. An object is expressed by the variable and methods within the objects. Again these variables and methods are distinguished from each other as instant variables, instant methods and class variable and class methods

Methods : We know that a class can define both attributes and behaviors. Again attributes are defined by variables and behaviors are represented by methods. In other words, methods define the abilities of an object.

Inheritance : This is the mechanism of organizing and structuring software program. Though objects are distinguished from each other by some additional features but there are objects that share certain things common. In object oriented programming classes can inherit some common behavior and state from others. Inheritance in OOP allows to define a general class and later to organize some other classes simply adding some details with the old class definition. This saves work as the special class inherits all the properties of the old general class and as a programmer you only require the new features. This helps in a better data analysis, accurate coding and reduces development time.

Abstraction : The process of abstraction in Java is used to hide certain details and only show the essential features of the object. In other words, it deals with the outside view of an object (interface).

Encapsulation -: This helps in hiding an object's data describing its state from any further modification by external component.This is an important programming concept that assists in separating an object's state from its behavior. In Java there are four different terms used for hiding data constructs and these are public, private, protected and package.

Polymorphism : Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.Any java object that can pass more than one IS-A test is considered to be polymorphic. In Java, all java objects are polymorphic since any object will pass the IS-A test for their own type and for the class Object.

JIT:Just in Time Compiler
When JVM compiles the class file he does not compile
the full class file in one shot. Compilation is done on function basis or file basis. Advantage gained from this is that heavy parsing of original source code is avoided. Depending on need basis the compilation is done. This typ of compilation is termed as JIT or Just-in-Time compilation.

Just-in-time compiler is a compiler used to convert the Commmon Intermediate Language (CIL) code into native code (also called machine code) that is processed by machine.

A little description
While compiling of .NET program, its code is converted into Common Intermediate Language code that is done by Common Language Runtime.
But while executing the program this CIL code is converted into Machine code or Native code that is done by JIT Compiler.

Abstract Class :
An abstract class is a class that is declared by using the abstract keyword. It may or may not have abstract methods. Abstract classes cannot be instantiated, but they can be extended into sub-classes.
--or--
Java provides a special type of class called an abstract class. Which helps us to organize our classes based on common methods. An abstract class lets you put the common method names in one abstract class without having to write the actual implementation code.

An abstract class can be extended into sub-classes, these sub-classes usually provide implementations for all of the abstract methods.

The key idea with an abstract class is useful when there is common functionality that's like to implement in a superclass and some behavior is unique to specific classes. So you implement the superclass as an abstract class and define methods that have common subclasses. Then you implement each subclass by extending the abstract class and add the methods unique to the class.

Points of abstract class :

Abstract class contains abstract methods.
Program can't instantiate an abstract class.
Abstract classes contain mixture of non-abstract and abstract methods.
If any class contains abstract methods then it must implements all the abstract methods of the abstract class.

Access Modifiers in Java :

All the four public, private, protected and no modifer is allowed.

public and no modifier – the same way as used in class level.
private – members CAN ONLY access.
protected – CAN be accessed from ‘same package’ and a subclass existing in any package can access.

For better understanding, member level access is formulated as a table:

Access Modifiers	Same Class	Same Package	Subclass	Other packages
public	Y	Y	Y	Y
protected	Y	Y	Y	N
no access modifier	Y	Y	N	N
private	Y	N	N	N

First row {public Y Y Y Y} should be interpreted as:

Y – A member declared with ‘public’ access modifier CAN be accessed by the members of the ‘same class’.
Y – A member declared with ‘public’ access modifier CAN be accessed by the members of the ‘same package’.
Y – A member declared with ‘public’ access modifier CAN be accessed by the members of the ‘subclass’.
Y – A member declared as ‘public’ CAN be accessed from ‘Other packages’.

Second row {protected Y Y Y N} should be interpreted as:

Y – A member declared with ‘protected’ access modifier CAN be accessed by the members of the ‘same class’.
Y – A member declared with ‘protected’ access modifier CAN be accessed by the members of the ‘same package’.
Y – A member declared with ‘protected’ access modifier CAN be accessed by the members of the ‘subclass’.
N – A member declared with ‘protected’ access modifier CANNOT be accessed by the members of the ‘Other package’.

similarly interpret the access modifiers table for the third (no access modifier) and fourth (private access modifier) records.

Difference between java and C ++

2012-08-21T10:49:00.001-07:00

C++ was designed for systems and applications programming, extending the C programming language. To this procedural programming language designed for efficient execution, C++ has added support for statically-typed object-oriented programming, exception handling, scoped resource management, and generic programming, in particular. It also added a standard library which includes generic containers and algorithms.
Java was created initially as an interpreter for printing systems but grew to support network computing. It is good for beginner programmers because it is easier to see how things work, with the already made methods(functions) being more like real words and it being very object-oriented. Sun Microsystems used to use it for the basis of their "HotJava" thin client system. It relies on a virtual machine to be secure and highly portable. It is bundled with an extensive library designed to provide a complete abstraction of the underlying platform. Java is a statically-typed object-oriented language that uses a syntax similar to C++, but is not compatible with it. It was designed from scratch with the goal of being easy to use and accessible to a wider audience. It has a thing called Javadoc that explains every part in detail.^[vague] It is usually 1X - 4X slower than C++.^{[citation needed]}