Monday, June 24, 2013

JDBC 7 STEPS :

Seven Steps to JDBC
      The java program can access the database using JDBC. the seven steps that are needed to access database are
1.    Import the package
2.    Load and register the driver
3.    Establish the Connection
4.    Create a Statement object
5.    Execute a query
6.    Process the result
7.    Close the connection
Step1: Import java.sql package
          The important classes and interfaces of JDBC are available in the java.sql package . So inorder to access the databases it must be imported in our application.
 import java.sql.*;
Step 2: Loading and registering the driver
           In order to access database it must have the particular driver for that database. In Java we have to inform the Drive Manager about the required driver this is done with the help of the method forName(String str) available in  the class named Class
Class.forName(“path with driver name”);
          In an application the user can register more than one driver. The statement used to load and register the JDBC-ODBC bridge driver is
                    Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
Step 3: Establishing the connection
           Establishing connection means making a connection to access RDBMS through JDBC driver. The connection can be established with the help of getConnection() method available in DriverManager class. The established connection is then set to new connection object.
Connection cn=DriverManager.getConnetion (“jdbc:odbc:DSN”, ”administrator”, “password”);
            Where DSN-Data Source Name
  When the statement is executed the connection is set to the Connection object cn. For example to connect the ODBC data source named mydata via JDBC –ODBC bridge the statement is
          Connection cn= DriverManager.getConnection (“jdbc:odbc:mydata”);
Step 4: Creating the statement
        A Statement object is used for executing a static SQL statement and obtaining the results produced by it. The createStatement() method is used to create statements using the established connection.
The methods used for creating the statements are
·         Statement createStatement()
Returns a new Statement object.Used for general queries
·         PreparedStatement prepareStatement(String sql)
Returns a new PreparedStatement object.For a statement called multiple times with different values (precompiled to reduce parsing time)
·         CallableStatement prepareCall(String sql)
Returns a new CallableStatement object for stored procedures
Step 5: Executing the Query
          After making connection to the database we are ready to execute the SQL statements. The  various methods available in Statement object to execute the query are
·         ResultSet executeQuery(String)
           Execute a SQL statement that returns a single ResultSet. After executing the SQL statements the requested data is stored in the ResultSet object.
·         int executeUpdate(String)
          Execute a SQL INSERT, UPDATE or DELETE statement. Returns the number of rows changed.
·         boolean execute(String)
           Execute a SQL statement that may return multiple results.
Step 6: Retrieving the result.
          A ResultSet provides access to a table of data generated by executing a Statement.Only one ResultSet per Statement can be open at once.The table rows are retrieved in sequence. A ResultSet maintains a cursor pointing to its current row of data. The 'next' method moves the cursor to the next row.
Methods:
·         public boolean first()
Moves the cursor to the first row in this ResultSet object.
·         public boolean last()
Moves the cursor to the last row in this ResultSet object.
·         public boolean next()
Moves the cursor down one row from its current position.
The methods used to retrieve the values from the current row
·         Type getType(int columnIndex)
Returns the given field as the given type. Fields indexed starting at 1 (not 0)
·         Type getType(String columnName)
Returns the data at the specified column
In the above methods the Type should be replaced by the valid datatypes such as Boolean, String, Int, Long, Float etc as getString(Column name), getInt(column index) etc.
Step 7: Closing the connection and statement
          When the client request is completed we have to close the created objects of Connection and Statement using close() method.
st.close();
cn.close();


Wednesday, February 6, 2013

Primitive Data Types:


Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory.
Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals, or characters in these variables.
There are two data types available in Java:
  • Primitive Data Types
  • Reference/Object Data Type
There are eight primitive data types supported by Java. Primitive data types are predefined by the language and named by a key word. Let us now look into detail about the eight primitive data types.

byte:

  • Byte data type is a 8-bit signed two's complement integer.
  • Minimum value is -128 (-2^7)
  • Maximum value is 127 (inclusive)(2^7 -1)
  • Default value is 0
  • Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is four times smaller than an int.
  • Example : byte a = 100 , byte b = -50

short:

  • Short data type is a 16-bit signed two's complement integer.
  • Minimum value is -32,768 (-2^15)
  • Maximum value is 32,767(inclusive) (2^15 -1)
  • Short data type can also be used to save memory as byte data type. A short is 2 times smaller than an int
  • Default value is 0.
  • Example : short s= 10000 , short r = -20000

int:

  • Int data type is a 32-bit signed two's complement integer.
  • Minimum value is - 2,147,483,648.(-2^31)
  • Maximum value is 2,147,483,647(inclusive).(2^31 -1)
  • Int is generally used as the default data type for integral values unless there is a concern about memory.
  • The default value is 0.
  • Example : int a = 100000, int b = -200000

long:

  • Long data type is a 64-bit signed two's complement integer.
  • Minimum value is -9,223,372,036,854,775,808.(-2^63)
  • Maximum value is 9,223,372,036,854,775,807 (inclusive). (2^63 -1)
  • This type is used when a wider range than int is needed.
  • Default value is 0L.
  • Example : int a = 100000L, int b = -200000L

float:

  • Float data type is a single-precision 32-bit IEEE 754 floating point.
  • Float is mainly used to save memory in large arrays of floating point numbers.
  • Default value is 0.0f.
  • Float data type is never used for precise values such as currency.
  • Example : float f1 = 234.5f

double:

  • double data type is a double-precision 64-bit IEEE 754 floating point.
  • This data type is generally used as the default data type for decimal values. generally the default choice.
  • Double data type should never be used for precise values such as currency.
  • Default value is 0.0d.
  • Example : double d1 = 123.4

boolean:

  • boolean data type represents one bit of information.
  • There are only two possible values : true and false.
  • This data type is used for simple flags that track true/false conditions.
  • Default value is false.
  • Example : boolean one = true

char:

  • char data type is a single 16-bit Unicode character.
  • Minimum value is '\u0000' (or 0).
  • Maximum value is '\uffff' (or 65,535 inclusive).
  • Char data type is used to store any character.
  • Example . char letterA ='A'

Reference Data Types:

  • Reference variables are created using defined constructors of the classes. They are used to access objects. These variables are declared to be of a specific type that cannot be changed. For example, Employee, Puppy etc.
  • Class objects, and various type of array variables come under reference data type.
  • Default value of any reference variable is null.
  • A reference variable can be used to refer to any object of the declared type or any compatible type.
  • Example : Animal animal = new Animal("giraffe");

Java Literals:

A literal is a source code representation of a fixed value. They are represented directly in the code without any computation.
Literals can be assigned to any primitive type variable. For example:
byte a = 68;
char a = 'A'
byte, int, long, and short can be expressed in decimal(base 10),hexadecimal(base 16) or octal(base 8) number systems as well.
Prefix 0 is used to indicates octal and prefix 0x indicates hexadecimal when using these number systems for literals. For example:
int decimal = 100;
int octal = 0144;
int hexa =  0x64;
String literals in Java are specified like they are in most other languages by enclosing a sequence of characters between a pair of double quotes. Examples of string literals are:
"Hello World"
"two\nlines"
"\"This is in quotes\""
String and char types of literals can contain any Unicode characters. For example:
char a = '\u0001';
String a = "\u0001";
Java language supports few special escape sequences for String and char literals as well. They are:
NotationCharacter represented
\nNewline (0x0a)
\rCarriage return (0x0d)
\fFormfeed (0x0c)
\bBackspace (0x08)
\sSpace (0x20)
\ttab
\"Double quote
\'Single quote
\\backslash
\dddOctal character (ddd)
\uxxxxHexadecimal UNICODE character (xxxx)

Monday, February 4, 2013

Java Versions, Features and History


A popular interview question in java is “what is new in Java version X?”. Is that an intelligent question is debatable. I have summarized below important new features added in each major java release till now. I target to highlight important features added in respective release. Apart from below list of features, every release has enhancements and lots of bug fixes.
Java Version SE 7
Code named Dolphin and released on July 28, 2011.
New features in Java SE 7
·         Strings in switch Statement
·         Type Inference for Generic Instance Creation
·         Multiple Exception Handlin
·         Support for Dynamic Languages
·         Try with Resources
·         Java nio Package
·         Binary Literals, underscore in literals
·         Diamond Syntax
·         Automatic null Handling
Java Version SE 6
Code named Mustang and released on December 11, 2006.




New features in Java SE 6
·         Scripting Language Support
·         JDBC 4.0 API
·         Java Compiler API
·         Pluggable Annotations
·         Native PKI, Java GSS, Kerberos and LDAP support.
·         Integrated Web Services.
·         Lot more enhancements.
J2SE Version 5.0
Code named Tiger and released on September 30, 2004.
New features in J2SE 5.0
·         Generics
·         Enhanced for Loop
·         Autoboxing/Unboxing
·         Typesafe Enums
·         Varargs
·         Static Import
·         Metadata (Annotations)
·         Instrumentation
J2SE Version 1.4
Code named Merlin and released on February 6, 2002 (first release under JCP).

New features in J2SE 1.4
·         XML Processing
·         Java Print Service
·         Logging API
·         Java Web Start
·         JDBC 3.0 API
·         Assertions
·         Preferences API
·         Chained Exception
·         IPv6 Support
·         Regular Expressions
·         Image I/O API
J2SE Version 1.3
Code named Kestrel and released on May 8, 2000.

New features in J2SE 1.3
·         Java Sound
·         Jar Indexing
·         A huge list of enhancements in almost all the java area.
J2SE Version 1.2
Code named Playground and released on December 8, 1998.

New features in J2SE 1.2
·         Collections framework.
·         Java String memory map for constants.
·         Just In Time (JIT) compiler.
·         Jar Signer for signing Java ARchive (JAR) files.
·         Policy Tool for granting access to system resources.
·         Java Foundation Classes (JFC) which consists of Swing 1.0, Drag and Drop, and Java 2D class libraries.
·         Java Plug-in
·         Scrollable result sets, BLOB, CLOB, batch update, user-defined types in JDBC.
·         Audio support in Applets.
JDK Version 1.1
Released on February 19, 1997
New features in JDK 1.1
·         JDBC (Java Database Connectivity)
·         Inner Classes
·         Java Beans
·         RMI (Remote Method Invocation)
·         Reflection (introspection only)
JDK Version 1.0
Codenamed Oak and released on January 23, 1996.