QnA

Yes

primitive by value &objects by reference.

1) Association is a channel between classes through which messages can be sent. As sending messages translates to calling methods in Java,Associations are typically (but not necessarily) implemented by references.
2) An Aggregation is an Association which denotes an “is part of”relationship. Unfortunately,the definition of this relationship is quite lax,so basically everyone is using his own interpretation. The only definitive (?) property is that in an instance graph,aggregations are not allowed to be circular –that is,an object can not be “a part of itself”. (or) When building new classes from existing classes using aggregation,a composite object built from other constituent objects that are its parts.Java supports aggregation of objects by reference,since objects can’t contain other objects explicitly.
3) A Composition adds a lifetime responsibility to Aggregation. In a garbage collected language like Java it basically means that the whole has the responsibility of preventing the garbage collector to prematurely collect the part –for example by holding a reference to it. (In a language like C++,where you need to explicitely destroy objects,Composition is a much more important concept.) Only one whole at a time can have a composition relationship to a part,but that relationship doesn’t need to last for the whole lifetime of the objects –with other words,lifetime responsibility can be handed around.

No. The method which gets called depends upon the type of reference &not on the object it points to.

1) Factory pattern

2) Single ton pattern

3) Prototype pattern

4) Abstract factory pattern

5) Builder pattern

1) Method overloading

2) Method overriding through inheritance

3) Method overriding through the Java interface

By making all instance variables private &defining getter setter methods.

If,however,you need to frequently add and remove elements from the middle of the list and only access the list elements sequentially,then LinkedList offers the better implementation.

The elements are sorted according to the natural order of elements or by the comparator provided at creation time.

Data is sorted according to ascending order of keys according to the natural order for the key’s class,or by the comparator provided at creation time.

Hashmap Hashtable

Single null key &multiple null key &values are not allowed.

null values allowed.

Iterator is fail-safe Enumerator is not failsafe

Not synchronized. Synchronized.

Yes. Constructors in concrete subclasses can call super().

Automatic conversion between primitive data &their wrapper classes.

Generics provides a way to communicate to the compiler,the kind of objects a particular collection will hold. This eliminates the need to do explicit casting whenever we are fetching elements from a collection. Since the type check is done at compile time,it guarentees that at runtime no class cast exceptions are thrown.

Whenever a object of String class is created using ‘=’a object is created in String pool of the JVM but in case the object is created using ‘new’keyword,two objects get created,one goes to non-pooled memory i.e. normal memory and the other goes to String pool memory. Only one reference will be created in this case as well as in the prior case.

This concept arises from the ‘Immutability’of String class. Immutability of a string means that whenever a object of type String is created,it gets memory in String pool and will stay there forever (Until the JVM restarts). Any further String objects created with same string as value will refer to the same String from string pool. This is better explained in a example below:

String str1 = "abc"';
System.out.println(str1.hashcode());// Output 1

String str2 = “abc”;
System.out.println(str2.hashcode());// Output 2

This is worth noting that the ‘Output 1′and ‘Output 2′will be same justifying the immutability of Strings.

StringBuffer is synchronized whereas builder isn’t.

StringBuilder offers better performance than buffer. we should use it when we dont want synchronization.

ClassNotFoundException –class not in classpath

NoClassDefFoundError –class definition could not be loaded. Main reason for this is,there is a static block in class definition and an exception was thrown from one of the statements in static block.

int i = (flag==true)?1,0;

same as

if(flag == true)

i = 1;

else

i = 0;

Externalization is extracting the String displayed on UI into a properties file.

Localization is creating locale specific files,for storing display strings.

Webservers are used to serve static content &offer no processing.

App servers can serve static as well as dynamic content &offer server side processing.

With static import,you can import members of a class as well.

e.g. there is class say Math which has a constant like PI &method like cos().

Ideally we will import Math class &use Math.PI or Math.cos().

Using static import like below,

import java.lang.Math.*;

We can use PI or call cos() directly as if it were the memeber of executing class.

It tells whether a given string is a valid number or not.

It returns true,if given string is NOT a valid number.

Reference by index

var arr = new Array();

arr[0] = “test1″;

arr[1] = “test2″;

var result = arr[1];//Gets the object at index 1

Reference by name(key). This is similar to HashMap in Java.

var arr = new Array();

arr["alpha"] = “test1″;

arr["beta"] = “test2″;

arr["gamma"] = “test2″;

var result = arr["beta"];//Gets the object which was stored with key “beta”i.e. “test2″.

JSON (JavaScript Object Notation) is a lightweight data-interchange format.

var timerId = window.setInterval(“foo()”,2000);//calls function foo(),at every 2 seconds,infinitely.

window.clearInterval(timerId);//Stops calling the function.

window.setTimeout("foo()",2000);//calls function foo() once after 2 seconds.

//return a random integer between 0 and 10

var randomNum = Math.floor(Math.random()*11);

var str=”The rain in SPAIN stays mainly in the plain”;

var regEx = /ain/gi;

‘ain’is matching string,‘g’means global means search all occurances,‘i’means case insensitive search.

alert(str.match(patt1));

Result –ain,AIN,ain,ain

var userAgent = navigator.userAgent;

alert(userAgent);

Following link has userAgent values for different browser+Operating system combinations.

http://www.zytrax.com/tech/web/browser_ids.htm

By doing userAgent.indexOf(),you can identify client’s browser type,version &OS.

It encodes a given string.

var str = “Need tips? Visit W3Schools!”;

var escStr = escape(str);

alert(escStr);

// returns Need%20tips%3F%20Visit%20W3Schools%21

Imagine there a very big page and you need to update only small part.

Using AJAX,you can achieve this without reloading entire page.

This saves time &bandwidth.

Application feels more responsive.

All modern browsers have built-in AJAX function.


var ajax =new XMLHttpRequest();


Whereas for older versions of IE(5,6) you can do,

var ajax = new ActiveXObject(“Microsoft.XMLHTTP”);

Thus following code should work on all browsers,

var xmlhttp;

if (window.XMLHttpRequest)

{// code for IE7+,Firefox,Chrome,Opera,Safari

xmlhttp=new XMLHttpRequest();

}

else

{// code for IE6,IE5

xmlhttp=new ActiveXObject(“Microsoft.XMLHTTP”);

}

Create xmlhttp object.

var xmlhttp;

if (window.XMLHttpRequest)

{// code for IE7+,Firefox,Chrome,Opera,Safari

xmlhttp=new XMLHttpRequest();

}

else

{// code for IE6,IE5

xmlhttp=new ActiveXObject(“Microsoft.XMLHTTP”);

}

GET request

var url = “getdata.jsp”;

var params = “language=en&country=us”;

xmlhttp.open(“GET”,url+”?”+params,true);

xmlhttp.onreadystatechange = function(){//Call a function when the state changes.

//readyState 4 means,the data is fetched &available in xmlHttp object.

if(xmlhttp.readyState == 4 &&xmlhttp.status == 200){

alert(xmlhttp.responseText);

}

}

http.send(null);

POST request

var url = “getdata.jsp”;

var params = “lorem=ipsum&name=binny”;

http.open(“POST”,url,true);

//Send the proper header information along with the request

xmlhttp.setRequestHeader(“Content-type”,“application/x-www-form-urlencoded”);

xmlhttp.setRequestHeader(“Content-length”,params.length);

xmlhttp.setRequestHeader(“Connection”,“close”);

xmlhttp.onreadystatechange = function(){//Call a function when the state changes.

if(xmlhttp.readyState == 4 &&xmlhttp.status == 200){

alert(xmlhttp.responseText);

}

}

xmlhttp.send(params);

This is a mechanism,where a single event like mouse click,can “bubble”upwards to the parent elements up in hierarchy from the child element that was actually clicked.

Following page explains event bubbling in detail.

Event bubbling

Check below page to see how to cancel bubbling at a particular level of hierarchy.

Cancel bubbling

document.oncontextmenu = new Function(“return false;”)

document.onkeypress = handleKeyPress;

See below for list of supported events.

DOM Events

A Cookie is like database on browser,which is only accessible to the website that sets it.
To set a cookie.


document.cookie = "language_preference=eng";


To read a cookie.


var cookieStr = document.cookie;


Cons:
1) Need to bind before runtime –Although binding before runtime usually allows for more optimized access plans,doing this in a test or development environment can be cumbersome.
2) Lack of tooling support –most of current IDEs provide coding assistance with support for APIs like JDBC. The lack of support from development tools discourages the use of static SQL.

Dynamic SQL
===========
Pros:
1) IDEs and APIs –Using eclipse to develop Java code that interacts with the database using JDBC or JPA is much simpler than developing a SQLJ application.
2) Statement caching –Dynamic statement caching avoids the need to compile the same statement multiple times,increasing the performance to values close to static SQL. However,bear in mind that a cache miss will be extremely expensive.
better statistics. Because the statement is compiled at runtime,it uses the latest statistics available,contributing to a better execution plan.

Cons:
1) Compile at runtime. There are a few reasons why compile at runtime can be a bad thing:
i] Every time a statement is executed,it needs to be compiled,increasing the total statement execution time
ii] The compile time will account for the total execution time,so using higher optimization levels may slow down the overall performance instead of improving it.
iii] Because the statement is only compiled at runtime,errors in the SQL statement won’t be detected until runtime.

To write the query,select from the same table listed twice with different aliases,set up the comparison,and eliminate cases where a particular value would be equal to itself.

Example -
List down employee’s &their manager’s name in one row.

SELECT e.first_name AS 'Employee FN',e.last_name AS 'Employee LN',m.first_name AS 'Manager FN',m.last_name AS 'Manager LN'
FROM employees AS e LEFT OUTER JOIN employees AS m
ON e.manager =m.id


class JDBCQuery
{
public static void main( String args[] )
{
try
{
// Load the database driver
Class.forName( “sun.jdbc.odbc.JdbcOdbcDriver”) ;

// Get a connection to the database
Connection conn = DriverManager.getConnection( “jdbc:odbc:Database”) ;

// Print all warnings
for( SQLWarning warn = conn.getWarnings();warn != null;warn = warn.getNextWarning() )
{
System.out.println( “SQL Warning:”) ;
System.out.println( “State:”+ warn.getSQLState() ) ;
System.out.println( “Message:”+ warn.getMessage() ) ;
System.out.println( “Error:”+ warn.getErrorCode() ) ;
}

// Get a statement from the connection
Statement stmt = conn.createStatement() ;

// Execute the query
ResultSet rs = stmt.executeQuery( “SELECT * FROM Cust”) ;

// Loop through the result set
while( rs.next() )
System.out.println( rs.getString(1) ) ;

// Close the result set,statement and the connection
rs.close() ;
stmt.close() ;
conn.close() ;
}
catch( SQLException se )
{
System.out.println( “SQL Exception:”) ;

// Loop through the SQL Exceptions
while( se != null )
{
System.out.println( “State:”+ se.getSQLState() ) ;
System.out.println( “Message:”+ se.getMessage() ) ;
System.out.println( “Error:”+ se.getErrorCode() ) ;

se = se.getNextException() ;
}
}
catch( Exception e )
{
System.out.println( e ) ;
}
}
}

Type 4 is the fastest.

Note:In Spring,you can specify @Transactional annotation,to declare that this method is called in transaction. Rest of the stuff is handled by Spring.

Dynamic Cursor
==============
A dynamic cursor,on the other hand,makes database changes available as they happen. Because the dynamic cursor requires the database provider to reorder data in the Recordset as it changes on the server,it is much more expensive than the static cursor in terms of the processing it requires. Also,because the order of the underlying records could change,only relative positioning is available to dynamic cursors. Lastly,dynamic cursors dont support bookmarks. If you need bookmark support,use a keyset or static cursor.

The type of cursor you select changes the efficiency of your application,as well as reliability of the data.When you access some data that is not frequently changed use a static cursor and vice-versa.

RowSet is a disconnected,serializable version of a JDBC ResultSet and also the RowSet extends the ResultSet interface so it has all the methods of ResultSet. The RowSet can be serialized because it doesn?t have a connection to any database and also it can be sent from one class to another across the network.

———————————————————–

1) The request received by hte ActionServlet which is the default Controller in Struts…
2)ActionServlet then call RequestProcesser.preProcess method to find the formbean,populate the value to it,validate the values..
3)Once the validating has finished,the ActionServlet’s RequestProcesser.preProcess() method call Action class’s execute method where the original business processing begins….
4)The action class process the method and reurns the result to ActionServlet…..
5)In returning the Action class provides the key to the corresponding ActionServlet to determine the reult acqiured fromprocessing will be diplayed…
6)The ActionServlet then display results to client using the key provided by the action class.

Within error.jsp,if you indicate that it is an error-processing page,via the directive:
<%@ page isErrorPage="true" %>

The bottom up approach does generate web services which design is driven from an application point of view (developer driven) and will not address the need for other consumers.

2. Application context module -
Implements BeanFactory &extends it’s functionality,by adding support for I18n messages,application life cycle events &validation.
It also provides enterprise services like email,JNDI access,EJB integration etc.

3. AOP(Aspect oriented programming) module -
Serves as basis of developing our own aspects in spring enabled application.

4. JDBC &DAO -
Abstracts away boilerplate code related to Data Access like getting connection,executing statements etc form the developer.
All configuration is moved to xml definition of bean.
Uses AOP module for transaction support.

5. O-R Mapping module -
Spring does not have it’s own OR mapping implementation,but provides hooks for several popular ORM frameworks like Hibernate,JDO etc.

6. Web module -
Builds upon Application Context module.
Provides context that is appropriate for web-based applications. Integration support with Jakarta Struts.

7. MVC Framework -
Spring has it’s own MVC framework,but it can also be integrated with Struts.
Allows to declaratively bind request parameters to business objects.

2. Service implementation or the actual Bean
Implements above service interface,by providing concrete service methods.

3. Spring config file
Tells the container,how to configure the bean.

4. Application classe that uses services provided by bean.


<bean id="dfOrder" class="com.att.yoda.dataInfo.DfOrder">
<property name="customerName">
<value>John Doe</value>
</property>
</bean>


o id –Name of the bean
o class –Bean’s fully qualified class name.
o <property>–Used to set property
o name –Name of the property in bean class. In example,this means we are asking spring to call setCustomerName() method.
o <value>–value of property “customerName”.

<bean id=”dfOrder”class=”com.att.yoda.dataInfo.DfOrder”>
<constructor-arg>
<value>John Doe</value>
</constructor-arg>
</bean>

2 FileSystemXmlApplicationContext –From xml file on file system.

3 XmlWebApplicationContext –From an xml file contained within a web application

Since this point,beans are ready to be used by the application. It will remain in bean factory till its no longer needed.