Tutorial #11

 Friends lets start this tutorial with an unusual topic called as Autoboxing, Unboxing & Annotation .

** Autoboxing & Unboxing
 These features are being introduced in J2SE 5.0, & facilitates the process of handling primitive data types in
collections.We can use this feature to convert primitive data types to wrapper class types automatically.

The compiler generates a code implicitly to convert primitive type to the corresponding wrapper class type &

vice-versa.  
       For example
               Double d_object = 100.2;
               double d_primitive = d_object.doublevalue( );
       Using autoboxing or unboxing feature, we can rewrite  the baove code as :
                Double d_object = 100.2;
                double d_primitive = d_object ;

But , java compiler provides restrictions to perform the following conversation:-

1. Convert from null type to any primitive type.
2. Convert to the null type other than the identify conversation.
3. Convert from any class type C to any array type if C is not object.

 ** Annotation

     It is also known as metadata. This feature is mainly used to merge additional Java elements with 

programming elements such as class, methods, local variable, package & fields.
               Metadata is stored in java class file by the compiler & these class files are used by the JVM or by 
the program to find the metadata for interacting with the programming elements. A nice definition is given by 
Wikipedia about annotation http://en.wikipedia.org/wiki/Java_annotation .This link provide a nice concept 
about annotation with various examples related to each types of annotation .
                
While using annotations, we need to follow some guidelines:

• Do not use extends clause, It automatically extends the marker interface java.lang.annotation.Annotation
• Do not use any parameter for a method
• Do not use generic methods
• Do not use throws clause.    

Lets consider an example on annotations:-
____________________________________________________________________________________
____________________________________________________________________________________

import java.lang.annotation.*;

import java.lang.reflect.*;

@Retention (RetentionPolicy.RUNTIME)

@interface MySingle

{

    int value() ;  //this variable name must be value

}

public class single

{

    //annotate a method using a marker

    @MySingle (100)

    public static void MyMeth ()

    {

        single ob = new single ();

        try

        {

            Method m = ob.getClass().getMethod("MyMeth") ;

            MySingle anno = m.getAnnotation(MySingle.class) ;

            System.out.println("The value is :"+anno.value());  //displays 100          

        }

        catch (NoSuchMethodException exc)

        {

            System.out.println("Method not found");

        }

    }

    public static void main (String args[])

    {

        MyMeth();

    }

}

To download this example in .java format that can run on eclipse by just pasting
the file in .src directory is given below:-

https://www.dropbox.com/s/u8y1qlay6mdsgw9/single.java 
___________________________________________________________________________________
___________________________________________________________________________________

** Interfaces : Multiple inheritance:-
     An interface is basically a kind of class. Like classes , interfaces contain methods & variables but with a 
major difference. The difference is that interfaces define only abstract  methods & final fields. This means 
that  interfaces do not specify any code to implement these methods & data fields contain only constants. 
Therefore, it is responsibility of the class that implement an interface to define the code for implementation of 
this method.
           Syntax-
               interface Interface_name
                {
                       varaible declaration;
                       method declaration;
                 }   

            Here variables are declared as follows:-
                       static final type Variable_name = value ;
            & method is defined as given below :-
                       return-type methodName1 (parameter_list) ;

     Note :-  Differences between Class & Interface:-

The member of the class can be constant or variables	Te member of an interface are always declared as constant, i.e=>their values are final
The class definition can contain the code for each of its methods	The method of an interface are abstarct in nature i.e=> there is no code associated with them . It is later defined by the class that implement the interface.
It can implement by declaring objects	It can-not be used to declare objects. It can only be inherited by a class.
It can use various access specifiers like public, private , or protected	It can only use public access specifier.

** Extending Interfaces
    Like classes interfaces can also be extended. That is , an interface can be sub-interfaced from other
interfaces. The new sub-interface will inherit all the members of the superinterface in a manner simplar to the
subclasses.
          Syntax :-
                 interface name2 extends name1
                 {
                               body of name2
                  }

         For eaxmple =>
             interface ItemConstants
             {
                      int code = 100 ;
                      string name = "fan" ;
             }
             interface item extends ItemConstants
             {
                      void display( ) ;
             }
 Note that variable name & code are declared like simple variables because all the variables in an inetrface

 are treated as a constants although the keyword final & static are not present.

                  We can also combine several interfaces together into one interface. For example the following
declaration is valid:-
             interface ItemConstants
             {
                      int code = 100 ;
                      string name = "fan" ;

             }
             interface itemMethods
             {
                      void display( ) ;

             }
             interface Item extends ItemConstants , itemMethods
             {
                   -----------------------
                   -----------------------
              }

While interfaces are allowed to extend other interfaces, sub-interfaces cannot be defined  the methods
declared in the superinterface.
          After all , subinterfaces are still interfaces , not classes. It is the responsibility of any class that
implement the derived interfaces to define all the methods.
           It is important to note that interface cannot extend class as it would violate the rule that an interface
can have only abstract methods & constants.

** Implementing interface
     Interfaces are used as "superclasses" whose properties are inherited by class who implement the interface
         Syntax:-
               class class_name implements interface_name
               {
                     body of class_name
                }
     Here the class class_name is implementing the interface interface_name.
     A more general form of implementation may look like this:-
                class class_name extends supercalss
                      implements interface1 , interface2, ........
                {
                      body of class_name
                 }

Take one example to understand the above explained concept :-
__________________________________________________________________________________
__________________________________________________________________________________

interface area

{

    final static float pi = 3.14F ;

    float compute(float x, float y);

}

class rectangle implements area

{

    public float compute (float x, float y)

    {

        return (x*y);

    }

}

class elipse implements area

{

    public float compute (float x, float y)

    {

        return (pi*x*y);

    }

}

class InterfaceTest

{

    public static void main(String args[])

    {

        rectangle rect = new rectangle();

        elipse cir = new elipse();

        area area1;

        area1 = rect;

        System.out.println("Area of rectangle="+ area1.compute(10,20));

        System.out.println("Area of elipse="+ area1.compute(10,35));

    }

}

 

 

To download this example in .java format that can run on eclipse by

just pasting the file in .src directory is given below:-

https://www.dropbox.com/s/dgpttzj1fhseerg/InterfaceTest.java 

__________________________________________________________________________________
__________________________________________________________________________________

**  Note:-
     Any number of dis-similar classes can implement an interface. However to implement the methods, we
need to refer to the class objects as type of the interface rather than of their respective classes.
     Note that if a class that implement an interface does not implement all the methods of the interface, then
the class becomes an  abstract class & cannot be instantiated.

Tutorial #10

In this tutorial we will try to understand the basic concept on Arrays, Strings & vectors that forms the backbone of the future topics that we are going to learn, as well as in the practical field of application development or web-development.

**  Arrays
      An array is a group of contiguous or related data items that share a common name , mainly they contains
      element of same data-type, but inbuilt array-list in java also supports insertion of objects that may 
      deoesn't belong to the same class .
           Types of arrays :-
     1.One dimensional array (1D)
        It represent basically one row or one column of elements .
                e.g=> marks obtained by four students in a subject 50,51,52,53
     2.Two dimensional array (2D)

        It represent a two dimensional matrix that contains m rows & n columns.
                 e.g=> [a,b,c ; 1, 2, 3]
     3.N-dimensional array (ND)
         It can be visualized as an N-dimensional matrix in N-dimensional vector space that is not realizable or
         being seen after N=3.
                  e.g=> [{a,b,c; 1,2,3 ; 4,5,6}; {a,b,c; 1,2,3 ; 4,5,6}; {a,b,c; 1,2,3 ; 4,5,6};{a,b,c; 1,2,3 ; 4,5,6}].

     Creating an array:-
    Creation of an array involves three steps:-
      1.  Declaring an array -  

                         type array_name[ ];                  or,

                         type[ ] array_name;

            Remember we do not enter the size of the array during declaration. 

       2. Creating an array 

                    array_name = new type[size] ;

       3.putting values into the memory location

                    array_name[subscript] = value;

                          e.g=> int table [2] [3] = {1,2,3,4,5,6} ;

        Unlike in C, Java protects array from overruns & underruns. Trying to access an array bound its
        boundaries will generate an error message.

**     Array length
         Java have an inbuilt function for getting the information about the number elements present in an array.
         We can obtain the length of array "a" using a.length
                           e.g=> int aSize = a.length

**     Strings
         String simply represents the sequence of characters & Java have inbuilt class for strings manipulation & processing called as "String" class.
         The syntax of  initializing string is given below:-
                    String string_name ;
                    String_name = new String ("string") ;
             e.g=> String firstName;
                       firstName =  new String("Anil") ;
     
          For more information on inbuilt String type & its per-implemented method visit the official site of Java given below
          http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/String.html

**    Vectors
        In this previous tutorial we saw the concept of variable argument method in Java. This feature can also be implemented in Java through the use of "Vector" class contained in "java.util" package.
                          This class can be used to create generic dynamic array known as vector that can hold objects of any type & any number. The objects do not have to homogeneous.

    Following are the main advantage of vector over array:-

1.     A vector can be used to store even inhomogeneous object that can very in size.
2.    We can add or delete objects from the list as & when required.

**  Wrapper class
      Primitive data-types (like char, int, float) may be converted into object type using wrapper classes
      contained in java.lang package.
       e.g=>
      Primitive datatype-->Wrapper Class-->Constructor arguments

1. boolean--> Boolean--> boolean or String
2. byte--> Byte--> byte or String
3. char--> Character--> char
4. short--> Short--> short or String
5. int-->Integer--> int or String
6. long--> Long--> long or String
7. float-->Float--> float double or String
8. double-->Double--> double or String

     Similarly we can  also convert object Numbers to Primitive number using "typeValue( )" method
     Method calling                                       Conversion action

1. int i = IntVal.intValue( );                        object to primitive integer
2. float f = FloatVal.floatvalue( );               object to primitive float
3. long l = LongValue.longValue( );            object to primitive long
4. double d = DoubleVal.doubleValue( );   object to primitive double  

_______________________________________________________________________
** Take an example program that simply implementted Calender class of java

import java.util.Calendar;
import java.util.Locale;

public class TestFormat {
    
    public static void main(String[] args) {
      long n = 461012;
      System.out.format("%d%n", n);      //  -->  "461012"
      System.out.format("%08d%n", n);    //  -->  "00461012"
      System.out.format("%+8d%n", n);    //  -->  " +461012"
      System.out.format("%,8d%n", n);    // -->  " 461,012"
      System.out.format("%+,8d%n%n", n); //  -->  "+461,012"
      
      double pi = Math.PI;

      System.out.format("%f%n", pi);       // -->  "3.141593"
      System.out.format("%.3f%n", pi);     // -->  "3.142"
      System.out.format("%10.3f%n", pi);   // -->  "     3.142"
      System.out.format("%-10.3f%n", pi);  // -->  "3.142"
      System.out.format(Locale.FRANCE,
                        "%-10.4f%n%n", pi); // -->  "3,1416"

      Calendar c = Calendar.getInstance();
      System.out.format("%tB %te, %tY%n", c, c, c); // -->  "May 29, 2006"

      System.out.format("%tl:%tM %tp%n", c, c, c);  // -->  "2:34 am"

      System.out.format("%tD%n", c);    // -->  "05/29/06"
    }
}

______________________________________________________________________________

Tutorial #9

This tutorial starts with abstract method & classes & will take us through method of putting variable argument

in calling function as well as different types of access specifier present in java  with few example on each topic.

      So lets starts with -

   Abstract Methods & Classes

   We have seen in our earlier tutorial that by using final we ensure that the method is not redefined in a subclass.

    Java also allow us to do something that is exactly opposite to this, i.e=> We can indicate that a method

 must allows be redefined in a subclass, thus making overriding compulsory. This is done using modifier

 keyword "abstract" in the method definition.

                      E.g=> abstract class Ball
                                 {
                                           -------------
                                           -------------
                                           abstract void cricket( );
                                           -------------
                                           -------------
                                  }

 If a class contains more than one abstract method then also it is to be defined in the same way as defined in

 the above example.

  If we are using abstract class we must have to satisfy the following conditions:-
  1. We can-not use abstract classes to instantiate object directly.
  2. The abstract methods of an abstract class must be defined in its subclass.
  3. We can-not declare abstract constructors or abstract static method.

 METHOD WITH VARARGS

 Varargs represent variable length arguments in method , which is one of the feature that is being introduced in J2SE 5.0

         Varargs syntex -

             <access specifier> <static> void method-name (object . . . arguments)
             {
                               -----------normal code (method body)-----------
              }

        NOTE- 1.The varargs must be final argument in the argument list of a method

                     2.Varargs does not generate any compile time error even if an empty argument is passed as a

                          parameter to a method

  Have a look at the example program to understand this concept properly:-

_______________________________________________________________________________
    // Illustrates the use of varargs to print the string value passed as an argument to a method
 class VariableArgs {
    VariableArgs (String... person ){
        for (String name: person){
            System.out.println("Hello"+ name);
        }
    }
   
    public static void main(String[] args) {
    new VariableArgs("John", "Rupali");       

    }
}
//The downloadable link for the above example is given below
  https://www.dropbox.com/s/kandq9kw35xbu5s/dyn_dis.java
______________________________________________________________________________

   Dynamic method dispatch

    It is an important mechanism in Java that is used to implement runtime polymorphism i.e=> In this

    mechanism . method overriding is resolved at runtime instead of compile time.

    

            Have a look at an example to understand this concept properly:-

____________________________________________________________________________
 class Super {
    public void method(){
        System.out.println("method super");   
    }
}

class sub extends Super{
    public void method(){
        System.out.println("Method sub");
    }
}

class dyn_dis{
    public static void main(String args[]){
        Super A= new sub(); //Sub's object refernces assigned Super type references variable
        A.method(); // sub's version of the method will be called
       
        Super B= new Super();
        B.method();  // super method will be called
       
        sub C= new sub();
        C.method();    // sub method will be called
    }
}

//The downloadable link for the above example is given below
     https://www.dropbox.com/s/kandq9kw35xbu5s/dyn_dis.java

____________________________________________________________________________

  Thus in dynamic method dispatch the type of reference variable is irrelevant while choosing a particular

   version of the overridden method for invocation;

                             Instead it solely depends on the type of object being referred by the reference variable.

   VISIBILITY CONTROL

   It mainly specifies the scope of variable & method's visibility outside the class inside the same package or even outside the package in which class is present.

   1. Public Access

     Any variable or method that is declared as public is visible to the entire class in which it is declared as well as visible even outside the class.

        E.g=> public int number;

                   public void sum ( ) {...........}

  2.Friendly access

       It is mainly invoked when non of the access specifier is declared across the variable or method , So it "default access specifier"

       The main difference between "public" & "friendly" access is that public modofier makes the field visible every-where regardless of package while friendly makes it visible only in same package.

  3. Protected Access

        The protected method makes the fields visible not only to all classes & subclasses in the same package

   but also to subclasses of other package

  4. Private Acess

       It enjoys the highest degree of protection where visibilty is only limted to its own class only

            E.g=> private int rome;

                       private int sum( );

  5. private protected aceess

       This gives the visibility level in between  "protected" access & "private" access. This modifier makes the fields visible in all subclasses regardless of package they are in. But they are not accessible by other classes in the same package.

   Rule of thumb:-

   1.Use "public" if the field is to be visible everywhere.

   2.Use "protected" if the field is to be visible everywhere in the crrent package but visible to only

      subclasses of other package.

   3.Use "default" if the field is to be visible everywhere in the current package only.

   4.Use "private protected" if the field is to be visible only in subclasses , regardless of packages.

   5. Use "private" if the field is not to be visible anywhere except its own class.

Tutorial #8

            Friends let’s start this tutorial from one of the basic technique that we haven’t discussed

    till now , the technique of taking data values from the user to process & writing data to the file 

    at any drive of our system.

            So here it goes

            Inputing data from the user or reading & writing in file

            import java.io.DataInputStream;

            import java.io.FileNotFoundException;

            import java.io.FileOutputStream;

            import java.io.IOException;

                        //creating a text file

            public class FileInput {

                        public static void main(String[] args) throws IOException {

                                    //attach a keyboard to data stream

                                    DataInputStream dis = new DataInputStream(System.in);

                                    //attach file to file output stream

                                    FileOutputStream fout = new FileOutputStream("d:\\myfile.txt",true);

                                    //read data from DataInputStream & write into FileOutputStream;

                                    char ch;

                                    System.out.println("enter data with '@' at the end");

                                    while((ch =(char)dis.read())!='@')

                                                fout.write(ch);

                                    fout.close();

            }

      }

**         Static Member (static method & static variable) in java

            The main advantage of static members is that it can be called without  instantiating the

     corresponding class (i.e=> without creating objects for that class).

            The common way of declaring static members (static method & static variable) is given  

      below-

                        static int count;                                                //static variable

                        static int max(int x , it z);                                 //static method

     The variable that are declared static is associated with the class itself, so it is changed by

     any object also affect its value in other object;

            Restriction imposed on static method-

1.    They can only call other static method;

2.    They can only access static data;

3.    They can-not refer to this or super in any way;

                        E.g=> example explaining  the concept of static method & static data properly.

**         Nesting of method

            A method can be called by its using only its name by another method of the same class.   

           This is known as nesting of methods.

                        E.g=> explaning properly about this concept(program 8.5)

**         Defining subclass

            A subclass is a class that usually inherits (or takes propertoies ) from some other

            prebuild class called as parent class (or superclass);

            syntax

                        class subclassname extends superclassname

                        {

                                    Variable declaration;

                                    Method declaration;

                        }

         The keyword extends signifies that the properties of the superclassname are extended to

         the superclassname.

          Note:- the constructor in the derived class uses super keyword to pass the value to its

          superclass.

                        E.g=> program showing single inheritance; (program 8.6) beauty

**         Features of subclass constructor

            Keyword super is used to subject the following condition-

·                  Super may only be used within a subclass constructor method

·                     The call to superclass constructor must appear as the first statement within the subclass  

            constructor.

·                     The parameter in the super() method for passing parameter to a subclass;

 

**         overriding method

            Defining a method in the subclass with same name & argument as being declared in the

            superclass is called as method overriding. When that method is called , the method

            defined in the subclass is called instead of super class & hence it overrides the

            superclass declared method..:)

                                  

**         Final variable & method

            All the methods can be overridden by default in subclass, if we don’t want to allow the

            subclass to override the member of the superclass we can declare them using “final”

            keyword

                        E.g=> final int length = 98;

                                    final void pension()

                                    {

                                    ----- function body------

                                    }          

            Final Class

            It is the class that can-not be subclassed . This is also being achieved by using the 

            keyword “final”.

                        E.g=> final class reaction {------ }

                                   final class action extends reaction {--------}

            So from the above example it is clear that a final class can act as subclass but it will 

            never act as superclass.

**         Finalizer method      

            This concept is just the opposite of initialization. As we know that java has automatic 

            runtime garbage collector that automatically frees the memory as soon as the program

            finishese execution. But object may holds other non-object resources that is being freed

            by finalize() method like file descriptor or window system fonts.

                                  This is similar to destructor method in C++;
       
            Here is the link to download .java file of the example program given in this tutorial 
            named as FileInput.java.
                 https://www.dropbox.com/s/e6lcl0r5u2zmfsz/FileInput.java

            Just you need to download this file and place it on src of myEclipse & it will get 
            ready to run..:)