overloaded methods, which method implementation will be executed at runtime is determined at compile time , but for overridden methods, the method implementation to be executed is determined at runtime.As the return type is not a part of the method signature, just having different return types is not enough to overload methods.

All arrays of reference types are also subtypes of the array type Object[], but arrays of primitive data types are not. Note that the array type Object[] is also a subtype of the Object type
covariant return types means subclass overrides method and return is subclass of the super class’s return.

Child class cannot reduce visibility of overriden methods , cannot increase count of checked exception, can only have covariant return type for methods.

Static methods if hidden are called based on the class of the reference.

Top t = new Bottom();
t.staticMethod – Top’s static method called. !.
If super class has non default constructor subclass must define the constructor on it’s own. Secondly, super has to be the first statement in the constructor.

conversion of int[] array to
Object array – since int[] is not subtype of Object[] – it is enapsulated as an object and passed. But String[] etc are subtypes of Object[]. []… is treated like a 2d array
All arrays of reference types are also subtypes of the array type Object[], but arrays of primitive data types are not. Note that the array type Object[] is also a subtype of the Object type

If a non-generic reference type is a subtype of another non-generic reference type, the corresponding array types also have an analogous subtype-supertype relationship. This is called the subtype covariance relationship. This relationship however does not hold for parameterized types .There is no subtype-supertype relationship between a type and its corresponding array type.

Method call for overloading rules – calls most specific method. Rules are:
1. It first performs overload resolution without permitting boxing, unboxing, or the use of a varargs call.
2. If phase (1) fails, it performs overload resolution allowing boxing and unboxing, but excluding the use of a varargs call.
3. If phase (2) fails, it performs overload resolution combining a varargs call,boxing, and unboxing.

———————NESTED—————-
Static member class can define both static and instance members, like
any other top-level class. However, its code can only directly access static members in its enclosing context.

——-
Instance of a non-static member class can only exist with an instance of its enclosing class. This means that an instance of a non-static member class must be created in the context of an instance of the enclosing class. This also means that a non-static member class cannot have static members. In other words, the non-static member class does not provide any services, only instances of the class do. However, final static variables are allowed, as these are constants.
• Code in a non-static member class can directly refer to any member (including nested) of any enclosing class or interface, including private members. No fully qualified reference is required.

To create a non static member class you need instance of the parent class:
MyLinkedList.Node node2 = list.new Node(“node2″, node1); // (17)

Multiple objects of the non-static member classes can be associated with an object of an enclosing class at runtime !!
list- > node1, node2, node3 – nice

From within the non static inner class – “this” has special meaning referring to the nested class itself. The outer this can be referred with appending of class name. [class].this.outerproperty.
private fields of outer context can be accessed
Eg:
MyLinkedList.this.message + ” in ” + this.nodeInfo

If you wish to extend a nested non static member class from outside you need to provide in the constructor mandatory an instance of the outer class: Unique format:
// (4) Mandatory non-default constructor:
SubclassC(OuterA outerRef) {
outerRef.super(); // (5) Explicit super() call
}

But if you extend outerA and innerA both – this above is not needed.
new OuterB().new InnerB(); is sufficient as subclasses.

Nested interfaces are always static

the scope of the Inner class, the doIt() method of the Outer class is hidden by the doIt() method of the Inner class

Non-static member classes, unlike top-level classes, can have any accessibility modifier.

Static member classes can only be declared in top-level or nested static
member classes and interfaces.

Local = method scoped classes. similar to non static member classes.
cannot have static members, final static fields are allowed, as these are constants.[diff] Local classes cannot have any accessibility modifier. Only finals/statics from enclosing method are accessible.
local class cannot be specified with the keyword static.

TLCWithLocalClasses.this.nsf1 – only for non static local class
static has no concept of OUTER object – so no “this” allowed in any form.

A non-static local class can access both static and non-static members defined in the enclosing class.static local class can only directly access members defined in the enclosing class that are static

instance block – forward reference of static field/method allowed.
All instances of concrete wrapper classes are immutable.
All wrapper classes except Boolean and Void have a compareTo() method. Only the numeric wrapper classes have an intValue() method.

Certain values are cached- as in only one wrapper objects exists for certain range of primitive values once created. so should not rely on object == when comparing wrappers.

equal objects must produce equal hash codes.For the sake of efficiency, a hash function should strive to produce unequal hash codes for unequal objects.

LinkedHashSet = LIFO movement.
Navigable = poll (first/last) + range operations = head/tail/sub = map/set., ceiling,floor, higher, lower , descending (map/set)

searching in hashmap/hashset faster than treemap/treeset.

Pattern.compile, p.match, greedy, reluctant, possesive qualifiers for regex.

If you want, this allows you to store your CSS path as an attribute in tiles-defs.xml, and retrieve it from your JSPs with the tag:

<link type="text/css" rel="stylesheet"
href="”/>

========================================================

tiles-defs.xml

<![CDATA[

]]>

Alternatively you can put the content into a separate jsp and then “tiles:insertAttribute” like any other content.

==============================================

one asterisk (*) for a single placeholder;
two asterisks (**) to say “in every directory under the specified one”;

Choose between UrlBasedViewResolver (TilesView + TilesConfigurer) and ResourceBundleViewResolver

=========================

<bean name="myController" class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <value>
            /**/*.xhtml=myController
        </value>
    </property>
</bean>

Use pixels for pixel-based things, like borders. You probably don’t want a border that ends up being 1.3422 pixels wide.

Use text-centric measures (em, ex) for text-based things, like content areas, labels, and input boxes. It’s an easy way to make sure you have room for text of a certain length and width.

Use percents for window-based things, like columns.
There are exceptions, of course. For example, you might want to specify a minimum column width in pixels. But follow the above and your pages will scale well. ALWAYS zoom in and out on your pages to see how they work with different font sizes and browser shapes — don’t get surprised later.

Define the context annotation scanner in the spring file. Define the hibernate template using the session factory using ref tag and not value tag. The JUnit test class has @Test annotated for test cases and the @RunWith (SpringRunner4JUnit.class) and @ContextConfiguration(“/abc.xml”)

That helps in running the test cases/ the autoDDL in hibernate if set to create recreates the schema everytime – instead to validate if you wish to keep data as it is in db.Otherwise data keeps getting removed.
validate: validate the schema, makes no changes to the database.
update: update the schema.
create: creates the schema, destroying previous data.
create-drop: drop the schema at the end of the session.

Logging can be increased by setting:

log4j.logger.org.hibernate.SQL=debug
log4j.logger.org.hibernate.type=trace

JTS = database driver
JTA = jdbc connector

To decide between “Required” and “Mandatory” – you need to see that if a method is not rolling back the transaction – then the method should be marked mandatory.

Transaction Isolation Level : Setting is DEPENDENT on the DB and the APPSERVER features.
But TxIsolation if high is low on concurrency and high on consistency. if low is high on concurrency and low on consistency.

Repeatable Read: These locks ensure that the rows touched by the query cannot be updated or deleted by a concurrent session until the current transaction completes (whether it is committed or rolled back). These locks do not protect rows that have not yet been scanned from updates or deletes and do not prevent the insertion of new rows amid the rows that are already locked.

Specifies that statements cannot read data that has been modified but not yet committed by other transactions and that no other transactions can modify data that has been read by the current transaction until the current transaction completes

Shared locks are placed on all data read by each statement in the transaction and are held until the transaction completes. This prevents other transactions from modifying any rows that have been read by the current transaction. Other transactions can insert new rows that match the search conditions of statements issued by the current transaction. If the current transaction then retries the statement it will retrieve the new rows, which results in phantom reads. Because shared locks are held to the end of a transaction

SERIALIZABLE
Specifies the following:
-Statements cannot read data that has been modified but not yet committed by other transactions.
-No other transactions can modify data that has been read by the current transaction until the current transaction completes.
-Other transactions cannot insert new rows with key values that would fall in the range of keys read by any statements in the current transaction until the current transaction completes.

3 DESIGN PATTERN for Transactions:
=============================================

1/ client managed tx model : client manages tx start and end and server domain service must not rollback tx and most importantly mark it as Mandatory. the tx is propagated through the RMI using programmatic[ejb]/declerative[spring] at Client and declarative at the server side.

2/ Domain Service Owner Transaction Model – places the responsibility of managing of Tx start/end type on the service layer. / declarative tx/
DAO – no tx responsibility. Client – no Tx respon

3/Server Delegate Owner Tx Design Pattern:
Instead of client making 40 independent calls to the server – or the domain services each managing the tx of 40 calls – setup all calls in the Command Object – that is processed by a bean (component) – so there is one component processor that manages all transactions – and all other domain services in the app are just simply used in the tx.
Command object is passed by the client to the server and the server has a bean that acts like a command tx method call processor.

2. Create one Event class that keeps reference of this handler in the GWT.Type class  and extends GWTEvent with a typed reference to the handler.

Event dispatches control to handler . Dispatch is called internally by a class managing events which call’s the associated type to verify that event match takes place.

Command line tools: http://code.google.com/webtoolkit/doc/1.6/RefCommandLineTools.html

to remember are that

• You want to put the GWT selection script as early as possible within the body, so that it begins fetching the compiled script before other scripts (because it won’t block any other script requests).
• If you are going to be fetching external images and scripts, you want to manage your two connections carefully.
• <img> tags are not guaranteed to be done loading when onModuleLoad() is called.
• <script> tags are guaranteed to be done loading when onModuleLoad() is called.

User	com.google.gwt.user.User
HTTP	com.google.gwt.http.HTTP
JSON	com.google.gwt.json.JSON
JUnit	com.google.gwt.junit.JUnit
XML	com.google.gwt.xml.XML
http://code.google.com/webtoolkit/doc/latest/DevGuideOrganizingProjects.html

http://code.google.com/webtoolkit/doc/latest/DevGuideCompilingAndDebugging.html

Restricting myself to the existing old database structure I used the Jboss Hibernate tools to recreate the POJO’s out of the tables. It creates one hbm file per table per class.

JPA on the other hand creates all the class references in the persistence.xml file only. Does not go for individual xml files.All settings done through annotations in the classes themselves. In one way it’s clean but again need to refer to both xml/java files always…

Restricting myself to Hibernate to start with. Question is – all the java files named after tables created in one folder with hbm files – is there a way to push them to their own structure of packaging – how do reverse engineering customization takes place? – Going through that now.

Thereafter need to do a simple login with user. And show user specific data from employee table. Edit Profile. And Save. Logout.

Then the mapping for the jsp file was not working for some reason? . Needed to switch on logging – so enabled dependency for slf4j and log4j. Attempting to first get jsp displayed and then the controller.

The problem was that you cannot get the jsp to be displayed directly without having the controller come into picture even if it is a plain vinalla jsp . The point is that if the control is passing through the DispatcherServlet then the handler for that should be existing – it cannot just pass it to the viewResolver without the controller.

Now issue was even after setting the urlFileNameController and the internalviewresolver the jsp was not being displayed. It was showing error as /snail/WEB-INF/jsp/home.jsp path not found.

The reason is the path setting in the internal view resolver. if you set prefix as :

/WEB-INF/jsp  - then this is a relative prefix- results in dispatcher path: /WEB-INF/jsp/home.jsp

If you set prefix as WEB-INF/jsp – then this is an absolute uri redirection : results in dispatcher path as  - WEB-INF/jsp/home.jsp

So the whole point is – in what format the redirection is taking place using the core RequestDispatcher class of the servlet API. Also , when one defines the mappings for the SimpleUrlHandlerMapping then the key should not include the servlet-mapping path – eg: not like /app/home but instead **/home/* or /home or home. That is also a point to take care for ensuring that uri mapping is found.

So then – the built in controller for this is URLFileNameViewController

read on maven clean prepare-package war:exploded

what is the goal and what is the phase?

when can we stop – how do we use the lifecycle list?

———–

White spaces are required between publicId and systemId.

The error comes because of not having the xsd corresponding to the namespace existing when defining new namespace using the spring tools plugins. The way to resolve it is ensure that in the schemaLocation you are mentioning first the namespace unique id and then a space followed by the xsd path. Eg:

xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd"

The below is incorrect:

xsi:schemaLocation=”http://www.springframework.org/schema/beans”"