Thursday, April 26, 2007

Core Java Programming

       Core java seems very difficult now a days....

Check out the following statements

        int i=1;

What do you think is the output of the above statements..
It is just a simple assignment and increment statement.

in i++
            i gets incremented only after the execution of the line,
so i=1+1
            so i =2 in second line
but in the third line the value of i should be incremented but as per the execution of the statement,
Value of i is got as 2
What happened to the increment.....

=+ and ++ cant execute in the same statement and same variable


Tuesday, April 24, 2007

Velocity intergration with struts

            Velocity is a Java-based template engine. It permits anyone to use a simple yet powerful template language to reference objects defined in Java code.
            When Velocity is used for web development, Web designers can work in parallel with Java programmers to develop web sites according to the Model-View-Controller (MVC) model, meaning that web page designers can focus solely on creating a site that looks good, and programmers can focus solely on writing top-notch code.
        Velocity separates Java code from the web pages, making the web site more maintainable over its lifespan and providing a viable alternative to Java Server Pages (JSPs) or PHP.

Five steps to Velocity

The recipe for combining Struts and the Velocity Template Engine is simple and straightforward; in fact, you can do it in just five steps:

   1. Place the Velocity JARs in your classpath.
   2. Modify the web.xml file to recognize the Velocity servlet.
   3. Place the Velocity toolbox.xml under your application's WEB-INF directory.
   4. Modify your struts-config to point its views to Velocity templates instead of JSPs.
   5. Create a Velocity template for each page you want to render.

        Let us take up an example to understand better.When we search for an ISBN, it should display the contents of the isbn.. For this example let us execute the five steps..

Step 1. Place the Velocity JARs in WEB-INF/lib

The Step 1 is the easiest.Download velocity jars and place them in WEB-INF/lib

Step 2. Modify web.xml to recognize the Velocity servlet

The next step is to modify the Struts web.xml file to recognize the Velocity servlet and direct all resources

request ending with .vm to the Velocity servlet

  <servlet-name>velocity</servlet-name> //declare the Velocity servlet and give it a handle of velocity.

    <param-name>org.apache.velocity.toolbox</param-name>// toolbox configuration location.


<!-- Map *.vm files to Velocity -->

The Velocity servlet takes a "toolbox" parameter. The toolbox is the place you declare the tools available to

your application.

Step 3. Place toolbox.xml under WEB-INF

The tool box bascially conntains all the tools. We define each of them with the key,scope and the class..

<?xml version="1.0"?>

Step 4. Modify struts-config

    Struts config should be modified to support velocity. There is no much difference if we have a velocity template forward the action to a *.vm pattern

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD
             Struts Configuration 1.0//EN"

        <form-bean name="searchForm" type="app.SearchForm"/>

        <forward name="welcome" path="/"/>

            <forward name="success"
Note that we can use both *.do and *.vm in the same application depending on the requirement.

Step 5. Create a Velocity template

velocity template for the example application's search page.

    $!errors.msgs() //$!errors.msgs() to get any error messages on the error-message queue.
    <FORM method="POST"
      action="$link.setAction('/search')"> //to obtain the URL for the search forward.
      <h2>Book Search</h2>
      ISBN:<INPUT type="text" name="isbn">
      <INPUT type="submit" value="Submit" name="submit">
Velocity template for the results page


  <h1>Book Details</h1>
  <a href="$link.setForward("searchEntry")">Search


    <b>No Pages:</b>$book.pages<br>

The action class sets a book object in session, which is retrieved and displayed in the velocity template.

This is a sample application with velocity and struts. Velocity does seems simpler than JSP's

Friday, April 13, 2007

Garbage Collection...

This is one topic which most of you know about. I was once asked by my senior to read about this.. And yes, i did read about that.

The Java Virtual Machine has 2 primary jobs:
# Execute Code
# Manage Memory

Memory Management involves 3 mail goals

# Allocate Memory from OS
# Manage Java Allocations
# Remove Garbage Objects

Garbage Collection involves around Memory management and it is one major advantage of Java over C or C++. One of our professors were very particular about freeing every memory used in C++ and I am happy that in Java, no need to care about it..
This is the second good reason for shifting to JAVA from C++. Not to forget the first reason "no pointers in java".

Memory allocation in Java is done in the heap, I mean there is one heap and objects are all allocated memory from this heap.

An object is created in the heap and is garbage-collected after there are no more references to it. Objects cannot be reclaimed or freed by explicit language directives.

Objects become garbage when there are no more references to the object.So, how do u say an object has no more references.

If no active threads have reference to this object, It is said eligible for GC.(All programs are said to me executed as threads and it starts executing from the main method.)

The garbage collector checks to see if there are any objects in the heap that are no longer being used by the application. If such objects exist, then the memory used by these objects can be reclaimed. (If no more memory is available for the heap, then the new operator throws an OutOfMemoryException.)

There are several GC algorithms in use today. Each algorithm is fine-tuned for a particular environment in order to provide the best performance. Let us see one of them.

Mark, Sweep and compact Algorithm.

Quite simple
# Mark: identify garbage
# Sweep: Find garbage on heap, de-allocate it
# Compact: collect all empty memory together

Every application has a set of roots. Roots identify storage locations, which refer to objects on the managed heap or to objects that are set to null. For example, all the global and static object pointers in an application are considered part of the application's roots. In addition, any local variable/parameter object pointers on a thread's stack are considered part of the application's roots. Finally, any CPU registers containing pointers to objects in the managed heap are also considered part of the application's roots. The list of active roots is maintained and is made accessible to the garbage collector's algorithm.

When the garbage collector starts running, it makes the assumption that all objects in the heap are garbage. In other words, it assumes that none of the application's roots refer to any objects in the heap. Now, the garbage collector starts walking the roots and building a graph of all objects reachable from the roots. For example, the garbage collector may locate a global variable that points to an object in the heap.

The collector continues to walk through all reachable objects recursively.

Once this part of the graph is complete, the garbage collector checks the next root and walks the objects again. As the garbage collector walks from object to object, if it attempts to add an object to the graph that it previously added, then the garbage collector can stop walking down that path. This serves two purposes. First, it helps performance significantly since it doesn't walk through a set of objects more than once. Second, it prevents infinite loops should you have any circular linked lists of objects.

Once all the roots have been checked, the garbage collector's graph contains the set of all objects that are somehow reachable from the application's roots; any objects that are not in the graph are not accessible by the application, and are therefore considered garbage. The garbage collector now walks through the heap linearly, looking for contiguous blocks of garbage objects (now considered free space). The garbage collector then shifts the non-garbage objects down in memory (using the standard memcpy function that you've known for years), removing all of the gaps in the heap.

There are many other Garbage collection algorithms too..

But what we need to know about them is
1) We never know when they get executed.
When the memory goes low, it is executed. We cannot manually start it. We can ask the compiler to do it but we cannot demand it to do it. It means when we ask it execute GC , it may or may not do it.

To ask the compiler.... use ,

System.gc();// call the static function


Runtime rt = new Runtime();

2) We can manually make the object eligible to be Garbage Collected.. by pointing it to null

int i=5;
After the function of the object or variable is over , one can make it to point to null to make it eligible to be Garbage Collected.

3) It doesn't Guarantee to provide enough space for your application.
When you go out of memory u cant rely on GC to remove all garbage and give u enough memory to run your application. It will remove only what it feels as Garbage , even after removing the garbage you might run out of memory.

Thursday, April 12, 2007

Overloading and Overridding

For long i thought , this is one of the simplest concept in java..
Both types of polymorphism have same method or function names .
In overriding , the function in the super class is over ridden by the subclasses and both have the same name , same parameters and same return types.

Over ridding example

class Animal
public void eat()

class Dog extends Animal
public void eat()//overriding eat of animal
public void befriendly()

public class Test
public static void main(String a[])
Animal a = new Dog(); dogs eat is called because at runtime a is an object if Dog.
a.befriendly();//Complier error.....

Animal a=new Dog (); means that the variable a is a animal reference variable at compile time and Dog's object during run time..
So, even though at runtime a.befriendly(); may run as a is a Dog's object , It will not compile because at compile time "a" is a animal reference.

In Overloading , the function in the same class or super class is overloaded whereby the functions have the same name and should have different number of parameters or different types of parameters and can have different return types.

Overloading Example

class Vehicle
public void parts(String part1)

class van extends Vehicle
public void parts(String head, String part1)// This is not over ridding the parts of the Vehicle class, it is overloading

public void parts(String head, String part1,String part2)

public class test2
public static void main(String a[])
Vehicle van = new van();"asdfasd","fads");//compiler error
Van v= new Van();"DF","Adsfa","Dfd");//legal

In here the Parts() of Vehicle is overloaded by parts of Van and not over ridden.
So when the compiler comes across
Vehicle van = new van();
It is Vehicles reference in the compile time , so"asdfasd","fads");
results in a compiler error..
Though at run time it may seem perfect..

You should keep in mind that

= > The method to be overloaded is decided at compile time.
= > The method to be overridden is decided at run time.
= > You can run only after you have compiled..

Wednesday, April 11, 2007

ERP --- Enterprise Resourse Planning

ERP - Short for enterprise resource planning, a business management system that integrates all facets of the business, including planning, manufacturing, sales, and marketing. As the ERP methodology has become more popular, software applications have emerged to help business managers implement ERP in many different business activities such as inventory control, order tracking, customer service, finance, human resource and so on.

In other words we can consider ERP to be a set of activities supported by mulit-mode application software or other business to manage important parts of business such as product planning, purchasing materials, maintaining inventories, interacting with suppliers and customers, tracking orders etc... . It also includes other aspects of business such as finance management or human resource management.

The term ERP originally implied systems designed to plan the use of enterprise-wide resources. Although the acronym ERP originated in the manufacturing environment, today's use of the term ERP systems has much broader scope. ERP systems typically attempt to cover all basic functions of an organization, regardless of the organization's business or charter. Business, non-profit organizations, non governmental organizations, governments, and other large entities utilize ERP systems.

Some organizations - typically those with sufficient in-house IT skills to integrate multiple software products - choose to only implement portions of an ERP system and develop an external interface to other ERP or stand-alone systems for their other application needs. For instance, the Peoplesoft HRMS and Financials systems may be perceived to be better than SAP's HRMS solution. And likewise, some may perceive SAP's manufacturing and CRM systems as better than PeopleSoft's equivalents. In this case these organizations may justify the purchase of an ERP system, but choose to purchase the PeopleSoft HRMS and Financials modules from Oracle, and their remaining applications from SAP.

Private constructor

What is a Private constructor . Why is a constructor made private.. This private, public and protected access modifiers are used always for two things..
1) To confuse u ;)
2) To allow and deny access to other classes.(As the name)
Private constructors prevent a class from being explicitly instantiated by callers.

I know the next question , When do u want the callers not to instantiate the class.

Whenever a class contains
* only static utility methods
* contains only constants
* type safe enumerations
* singletons
u can make their constructors private...

If the programmer does not provide a constructor for a class, then the system will always provide a default, no-argument constructor. To disable this default constructor, simply add a private constructor to the class. This private constructor can be empty.

Example of a class containing constants

public final class Consts {

* Prevent object construction outside of this class.
private Consts(){

public static final String NEW_LINE = "\n";
public static final String EMPTY_STRING = "";
public static final String SPACE = " ";
public static final String PERIOD = ".";
public static final String TAB = "\t";

//algebraic signs
public static final int POSITIVE = 1;
public static final int NEGATIVE = -1;
public static final String PLUS_SIGN = "+";
public static final String NEGATIVE_SIGN = "-";

the Consts class declared contains only static and final constants . When we have all static values in a class and their values cannot be changed why do you want to instantiate an object for it. We create objects for a class to hold different values of the variable defined in the class. So as the variables are final,w cant modify them and since they are static the same memory space will be used for all the objects instantiated so why should we instantiate for such type classes.