JAVA MATERIAL

                                       Java Material


-----------------------------------------------------------

{{TO DOWNLOAD THIS AND FULL BOOK IN PDF FORMAT USE THE LINK IN COMMENTS::(FOR ALL POSTS)}}
---------------------------------------------------------------------------------

Java launched in the year 1995 and before that it was known as oak. Java is the first and foremost platform independent language, that enable used to wide program that can be executed in multiple browsers independent of the platform.

Java Features

          1. Java is simple

          2. It is secure

          3. It is portable

          4. It is object oriented

          5. Robust

          6. Multithreaded,

          7. Architectural neutrals

          8. Interpreter

          9. High performance

          10. Distributed

          11. Dynamic

Java has two parts

          1. Applets

          2. Application

          An Application is a program that runs on your computer under the operating system of that computer.

          An Applet is actually tinny java program dynamically downloaded across in the network. Applets are platform independent code and highly secured code.

Java Byte Code

          It enable java program to solve both security and portability problems.

          Byte code is the highly optimized set of instructions design to be executed by java virtual machine .that is JVM is the interpreter for byte code.

          Translating java program into byte code makes it easier to run a program in a wide variety of environment, on a condition that JVM must implemented on a each platform.

First program in java

          Import java. Lang.*

                  

                   The default package imported in java. Lang .*

          Java is the root package, Lang is sub package, .* is include class and interfaces.

//Example. Java

Class Example

{

          public static void main(String args[])

          {

                   System.out.println(“This is the Simple java program”);

          }

}

          We cannot define anything outside the class.

Steps to execute the program 

1.     First save the program :->

You can save an any name.java independent of the class name. but you  must save your program the same name of the class name if the class is declared as public.

You  can have only one public class defined in a java program.

2.     Compiling the program :->

Javac filename. java

          After compilation it generates a  .class for every classes mention inside the program  .

3.     Execute java

We execute with class name with  consists of the main method.

Garbage Collections :->

          Since objects are dynamically allocated by using the new operator , in java language they are destroyed after their usage by an implicit process . in c++ first we must manually deallocate  the object using the delete operator, where as in java language we have a low priority  thread called as Garbage Collection. Witch removes the unused objects automatically from the memory.

Finalize()

          When an object need to perform some action before it gets destroy , such actions  are mention inside the method called finalize(). The garbage collector invokes the finalize method before it removes the object.

Command Line arguments

          Passing arguments in command line is called as Command line argument. These arguments are store in the String array whish is passed an argument for the main method .

Final Variable

         

          Final variable must be initialized in java.

          Once we declared in final variable does not change the value during execution

Final method

          Final method cannot be overridden.

Final class

          Final class cannot be inherited .

Innerclass.

          We can access the base class member functions inside the base class inner class.

          Nesting a class with in another class called as inner class.

          We cannot declared the object outside the holding class.

Using Super

          Super has two general form

                   They call super class constructors.

They are used to access the member of the super class that has been

hidden by sub class.

 Super keyword must be the first statement.

Overriding

          Method overriding

When the derived class method override the inherited base class with the Same signature then it is called as method overriding.

                   With respect to access specifier  the stronger access specifier override weaker access specifier.

Abstract class 

          Abstract class consists of both abstract method and concrete methods.

         

We cannot create a instance of abstract class.

          It act as a Base class .

We use the keyword abstract prior to the class and the function to mention them as abstract .

When you inherit abstract class method you must provide the all the abstract methods(method implementation)

Packages

·        Packages enabloe users to compartmentaliuzed class and interfaces into different packages , which enable simplification of class names and group set of classes and interfaces to perform a specifc task.

·        Package class must be a public.

Steps to create a package :-

1.     How to create

We use “package” keyword to create a package, this statement   must be the first statement of the program.

Eg:    package mypack;

2.     How to compile

Javac –d . filename.java

      The above statement will create a folder automatically the name of the package and copies the .class file into directory automatically

Eg:                   javac –d . Calculator .java

3.     How to use a package

import packagename.class name

eg:     import mypack.Calculator

    

when a import a package it includes only that corresponding class and interfaces not the subpackage class and interfaces.

	Private	Nomodifier	Protected	Public
Same class	Yes	Yes	Yes	Yes
Samepackage subclass	No	Yes	Yes	Yes
Samepackage non subclass	No	Yes	Yes	Yes
Different package sub class	No	No	Yes	Yes
Different package non-subclass	No	No	No	Yes

Interfaces

·        Interfaces is collection only abstract methods.we cannot define concrete methods

·        To create an interface we use the keyword “interface” and to use the keywords “implements” when you implement an interface we must provide the definition for all the abstract methods inside the interface.

·        Since everything is abstract by default, you need not use the keyword abstract.

·        An interface can extendes another interface, we cannot create an instance of an interface.

·        Interface is alternate for an multiple Inheritance.

·        A class can implements morethan one interface where as a class can extends only one class.

·        Variable must be final inside the interface.

Exception Handling

          The difference between the error and an exception is that an Error terminates the program, where as the exception situation can be handled & program will continue its exception.

          “CAN BE HANDLED”-----Exception.(divide by zero),

          “CANNOT BE HANDLED”-------Error( ; , data type missing)

What do you mean by CAN BE HANDLED & how are able to handle :

          Exceptions are object in java that is whenever an abnormal situation is raised in a program,the compiler (system) creates an object of that corresponding class that describes the error.

          The created object is thrown in to the block of code, where the situation is raised.The thrown object can be handled by the user using “try and catch” keyword or inform the method to handle using “ throws “ keyword.

          There are set of predefined class like “FileNotFound”,”ArrayIndexOutOfBounds”

Etc… which are called as Exception classes. These classes are used for handling Exception .Since there is an Exception class that describes the error situation, we (system) are able to handle it by creating an object of that class and throw it into the block of code which in term is handled using Exception keyword.

Exception key word

         

                   try, catch, throws, throw and finally

try and catch --- used by the user to handle the exception

throws –Instructing the CALLING METHOD to handle the exception

throw --- used to raise an exception manually, used in the case of  user defined Exception and system defined Exception.

Finally---the last block of statement to be executed after the exception.

How to create a user defined Exception Class

A simple class can be converted into an Exception by the following statement.

Class  MyException-simple base class

Class MyException extends java.lang.Exception-an Exception class

          Now by converting ordinary class to an Exception class , it will enable the corresponding class to handle exception that is an object of that class can be created and thrown into the block of code in case of an abnormal situation.

//Using Try & Catch

class TryCatch

{

          public static void main(String args[])

          {

                   int i=10;

                   try

     {

                             int j=i/0;

                             System.out.println("******");

                   }

                catch(Exception e)

                   {

                        System.out.println("Caught Error : "+e);

                   }

          System.out.println("------------------------");

          }

}

//Using Throws Keyword

import java.io.*;

class ThrowsDemo

{

          public static void main(String args[])throws Exception

          {

             BufferedReader br=new BufferedReader

               (new InputStreamReader(System.in));

              

                System.out.println("Enter the name");

                String name=br.readLine();

                 System.out.println("name:= "+name);

          }

}

//Using Throw Keyword

class ThrowsDemo extends Exception

{

    public ThrowsDemo()

      {

          System.out.println("User Defined Exception Raised");

       }

    public String getMsg()

      {

          return("Hey Catch Me");

       }

}

class UseMain

{

          public static void main(String args[])

          {

               try{

                   throw new ThrowsDemo();

                  

// or ThrowsDemo e1 =new Throwsdemo();

                     //  throw e1;

                   }

                   catch(ThrowsDemo e)

                   {

                             System.out.println("   "+e.getMsg());

                   }

          }

}       

//Using Try & Catch  & Finally

class TryCatchFinally

{

          public static void main(String args[])

          {

                   int i=10;

                   try{

                             int j=i/0;

                    }catch(Exception e)

                   {

                   System.out.println("Error :"+e);}

                   finally{

                   System.out.println("Must Execute This Statement");

                   }

          System.out.println("Out Of Try Catch Finally Statement");

          }

}

//MultiCatch Class

class MultiCatch

{

          public static void main(String args[])

          {

                   try{

                   int a=args.length;

                   System.out.println("A= "+a);

                   int b=42/a;

                   int c[]={1};

                   c[1]=99;

                   }

                   catch(ArithmeticException e)

                   {

                             System.out.println("Divide by 0:  "+e);

                   }

                   catch(ArrayIndexOutOfBoundsException e)

                   {

                             System.out.println("Array Index OOB:  "+e);

                   }

          System.out.println("After Try/Catch blocks :  ");

          }

}

//Nested Try Class

class NestTry

{

          public static void main(String args[])

          {

                   try

                   {

                      int a=args.length;

                      int b=42/a;

                      System.out.println("A= "+a);

                         try

                         {

                             if(a==1) a=a/(a-a);

                             if(a==2)

                             {

                                      int c[]={1};

                                      c[42]=99;

                             }

                          }

                          catch(ArithmeticException e)

                          {

                             System.out.println("Divide by 0:  "+e);

                          }

                         catch(ArrayIndexOutOfBoundsException e)

                        {

                             System.out.println("Array Index OOB:  "+e);

                        }

                   }catch(ArithmeticException e)

                      {

                             System.out.println("Divide by 0 : "+e);

                      }

          System.out.println("After Try/Catch blocks :  ");

          }

}

Thread

·        Java provides built in support for multithreading.

·        There are two kinds of multitasking.

1.     Process based

2.     Thread based

1.     Process based :

A process is a program that is executing .It is working with more than one application at the same time.

Eg:-        word ,excel

2.     Thread based

Thread is a smallest unit of displaced code having separate path of execution, that is single program can perform more than one task.

Eg:-  performing more than one task within the same application.

         

There are two ways to create a multithread program.

1.     Implementing runnable interface

2.     Extending thread clas

Thread life cycle                              

Synchronization

          When two or more threads need access to share the same resource we need some way to ensure that the resource will be used by only one thread at a time.

          We use Synchronized statement to synchronize the share resource

There are two ways Synchronize

1.     Use the Synchronized keyword before the method

2.     Use Synchronized block

1.     Synchronized public void call()

{

}

2.     Synchronized(object)

{

}

Interthread Thread Communication

          In some scenarios it becomes mandatory for thread to communicate with another thread to utilize the CPU for the maximum.

          During synchronization a thread ask to wait for indefinite period of time, with leads to increasing idle time of the CPU an deadlock.

          These scenarios Interthread Communication enable threads to be more efficient.

          To achieve Interthread Communication we use the following keyword wait(),notify(),notifyAll()

Wait()

This tells calling thread to give up the monitor and go to sleep until some other thread enters the same monitor and calls notify().

Notify()

          Wake of the first thread that called wait() on the same object.

notifyAll()

wakes up all the threads that called wait() on the same object. The highest priority thread will run first.

isAlive()

Determine if thread is running this method is used to check whether the thread is iaAlive or not.

join()

          It is wait for thread is to terminate,after a thread is completes the processing it invokes  join() conforming the completion of execution

Wrapper Class

          In java we can convert primitive type to an object type and object to primitive using wrapper classes.

Wrapper Class	Primitive Type
Integer	int
Character	char
Byte	byte
Float	float
Boolean	boolean
Double	double

                    

         

         

USING WRAPPER CLASSES & METHODS

In java most of the time the values are passed in the form of an Object.

We convert the primitive type to object types and objects to primitive type using Wrapper classes.

These classes provides set of function that will enable us to convert a single to data to multiple forms.

   For every data type provided , there is a corresponding wrapper class available.

ex. -   int     Integer       

          char   Characte

          byte   Byte

          boolean       Boolean

          double         Double

          short Short

          float  Float

         

         

etc...

Constructor Convertion;

          Double(double)

          Double d=new Double(20.20);

ex -

          double d=20.20;

Convert the above premitive type to an object type.

          Double d=new Double(d);

         

Member function called on an Object for conversion without a parameter

          int intValue()

          d.intValue();

Static function called on a Class name for conversion with a parameter

          static int parseInt(String)

          Integer.parseInt("100");

         

--------------------------------

int variable - double variable in an array

ar[3] is string having a double value;

int dd=Double.parseDouble(ar[3]);

          int i=(new Double(d)).intValue();

          s.setma1(new Double(Double.parseDouble(ar[3]))).intValue());

----------------------------------

File

This is used to specify the actual file in the disk. The file class encapsulates the specified argument enabling the user to work on the passed value with its function.

import java.io.*;

class TestFile

{

    public static void main(String arg[])

    {

          File f=new File(“c:\Test.java”);

          System.out.println("File ?"+f.isFile());

          System.out.println("CanRead ?"+f.canRead());

    }

}

FileStreams( IO Streams )

          There are two kinds of streams in java.

1.     Byte Stream

2.     Character Stream

Byte Stream : supports only ASCII format(0-255)

Class names are integrated with InputStream & OutputStream

Ex) BufferedInputStream / BufferedOutputStream

       FileInputStream/FileOutputStream

Character Stream : It supports UNICODE format . It supports more than 65 thousands characters enabling java to be multilingual language.

Class names are integrated with Reader & Writer

Ex)BufferedReader / BufferedWriter

      FileReader / FileWriter

import java.io.*;

class TestPrg

{

     public static void main(String arg[]) throws Exception

     {

          //character stream

          BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

          String name=br.readLine();

          System.out.println("Your Name :"+name);

          //Byte Stream

          DataInputStream din=new DataInputStream(System.in);

     }

}

Serialization

          Reading and writing information in the form of an object is called as Serialization. It is the process of converting an object to bit blob network transferable form.   From network form to an object form is Deserialization.

          We use two class ObjectInputStream and ObjectOutput Stream to process serialization.

          The class instance to be Serialized must implement the interface Serializable.

Serial Version Unique Identifier 

          Serial version unique Identifier enable user with back word compatibility of objects that is an older version of an object will be 7accept  by the modified version of the same object.

          Serialver –show  and obtain the unique serial version id which will be used in the modified in the previous version of the same class.

Jar( java archive)

          It is used to compress .java, .jip… into a single unit using the exe file is “jar”

          Jar has the following attributes

         

                   -c       creates a new archive

                   -t       list table of contents for archive 

                   -x      extract named (or all) file from archive

                   -u      update Existing archive

                   -v      general verbose output on standard output

                   -f       specify archive file name.

                   .         .

                   .         .

Utility Classes

          In command prompt type:-    

Javap java.util.Vector;

          Javap java.util.ArrayList

StreamTokenizar

          Tokenize the file   101 | ram | 67 | 89

                                      102 | Siva | 89 | 98 ….

DeprecatedAPI

         

          The compiler request the user not to use certain API’s.These API’s are called as deprecated API’s using these API’s leads to the message “overrides deprecated API’s.

import java.util.*;

class VectorClass

{

          public static void main(String arg[])

          {

                   Vector v=new Vector();

                   v.add("sss");

                   int m=100;

                   v.add(new Double(200.50));

                   v.add(new Integer(m));

                   int size=v.size();

                   System.out.println("Size "+size);

                   for(int i=0;i<size;i++)

                             System.out.println(v.get(i));

          }

}

-----------------------------------------------------------------------------------------

import java.io.*;

class TestPrg

{

     public static void main(String arg[]) throws Exception

     {

          //character stream

          BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

          String name=br.readLine();

          System.out.println("Your Name :"+name);

          //Byte Stream

          DataInputStream din=new DataInputStream(System.in);

     }

}

-----------------------------------------------------------------------------------------------

import java.io.*;

class UseFile

{

          public static void main(String args[])

          {

                   File f1=new File("d:\\SELVAM\\Threat.txt");

                   System.out.println("   "+f1.isFile());

                   System.out.println("   "+f1.isDirectory());

                   System.out.println("   "+f1.getPath());

          }

}

-------------------------------------------------------------------------------------------------------

import java.io.*;

class Employee implements Serializable //program for Serializable

{

          String name;

             

          public Employee(String s)

          {

                   name=s;

          }

          public  String getName()

          {

                   return name;

          }

}

class WriteObject

{

          public static void main(String args[])throws Exception

          {

                   File f=new File("c:\\t1.txt");

                   FileOutputStream fout=new FileOutputStream(f);

                   ObjectOutputStream oout=new ObjectOutputStream(fout);

                   Employee emp=new Employee("Serialization");

                   oout.writeObject(emp);

                             System.out.println(" Object Writting Successfully");

          }

}

class ReadObject

{

          public static void main(String args[])throws Exception

          {

                   File f=new File("d:\\SELVAM\\data.txt");

                   FileInputStream fin=new FileInputStream(f);

                   ObjectInputStream oin=new ObjectInputStream(fin);

                   Employee e=(Employee)oin.readObject();

                   System.out.println("Object Read  :  "+e.getName());

          }

}

JDBC

          It is collection of java class and interfaces which enable user to write a program that can communicate with the database.

          import java.sql.*;

steps

1.     Load your driver class

2.     Create connection

3.     Create statement

4.     Execute statement

Program:-

          import java.sql.*;

class TestJdbc

{

          Public static void main(String args[])throws Exception

          {

                   class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

                   connection con=DriverManager.getConnection(“jdbc:odbc:jdbcdsn”,” “,” “);

                   Statement st=con.createStatement();

                   ResultSet rs=st.executeQuery(“ select * from Student”);

                  

While(rs.next())

                   {

                             System.out.println(rs.getString(1));

                             System.out.println(rs.getString(2));

                   }

          }

}

Driver is using translate the data API to DB and DB to API, then using Driver establish the connection using the DSN(Data Source Name).

DSN is based on the Driver we create a connection, then call to Database and APIjava using Statement. 

Then Execute the Statement. The Statement is using sqlCommand.

Driver Types

          There are four kinds of Drivers

1.     Type –I  Driver( JdbcOdbc bridge Driver )

2.     Type-II  Driver( partial java native APIDriver )

3.     Type-III Driver( Net pure JavaDriver )

4.     Type-IV Driver( pure java Driver)