Difference between method and functions

A method is on an object.
A function is independent of an object.

For Java, there are only methods.
For C, there are only functions.

For C++ it would depend on whether or not you’re in a class.

In general: methods are functions that belong to a class, functions can be on any other scope of the code so you could state that all methods are functions, but not all functions are methods:

Take the following python example:

class Door:
def open(self):
print 'hello stranger'

def knock_door():
a_door = Door()


def orphan_function() :
print “I am not part of class so can never be called method”

The example given shows you a class called “Door” which has a method or action called “open”, it is called a method because it was declared inside a class. There is another portion of code with “def” just below which defines a function, it is a function because it is not declared inside a class, this function calls the method we defined inside our class as you can see and finally the function is being called by itself.

Java Tip : How to avoid an java.util.ConcurrentModificationException with ArrayList?

You need to add/delete an item in an ArrayList when you are iterating the list. You will receive the java.util.ConcurrentModificationException exception. For example, the following code will throw an exception after adding an item into list:

public class Sample {

  public static void main(String[] args) {

    List<Integer>  iList = new ArrayList<Integer>();
    for (int i = 0; i != 100; i++)

    int addValue = 1000;
    for (Integer i: iList) {
      if (i%10 == 0) {

To avoid java.util.ConcurrentModificationException exception, we can add an item through the iterator of list. If we do the same as the above code, the next access item in list via the iterator will generate the same exception.

public class Sample {

  public static void main(String[] args) {

    List<Integer>  iList = new ArrayList<Integer>();
    for (int i = 0; i != 100; i++)

    int addValue = 1000;

    for (ListIterator<Integer> itr = iList.listIterator(); itr.hasNext();) {
      Integer i = itr.next();
      if (i%10 == 0) {


wicket : Drag and Drop

Latest wicket support drag n drop English: Drag and Drop Ltd Logo
here is the link

here is the same code, simple define source and target ūüôā

        WebMarkupContainer container = new WebMarkupContainer("container");
    Model<String> model = Model.of(new String("AAA"));
    container.add(new DragSource(Operation.values()) {
          public void onAfterDrop(AjaxRequestTarget target, Transfer transfer) {

              System.out.println("Drag n drop");


    container.add(new DropTarget(Operation.values()) {
          public void onDrop(AjaxRequestTarget target, Transfer transfer, Location location) {
            // add transfer data


    Label label = new Label("aaa", model);


Javatip : Why do we have only public static final variables in interfaces?

An interface defines a protocol of behavior and not how you should be implemented. A class that implements an interface adheres to the protocol defined by that interface.

All fields declared within an interface are implicity public, static, and final. Why?

  • Any implementations can change value of fields if they are not defined as¬†final. Then they would become a part of the implementation.An interface is a pure specification without any implementation.
  • If they are static, then they belong to the interface, and not the object, nor the run-time type of the object.
  • An interface provide a way for the client to interact with the object. If variables were not public, the clients would not have access to them.

In general, a field declaration may include the following modifiers:¬†public, protected, private, final, static, transient, volatile. But only¬†public, final, and¬†static¬†are permitted for interface’s variable.

Every field declaration in the body of an interface is implicitly public, static, and final. It is permitted to redundantly specify any or all of these modifiers for such fields. Every field in the body of an interface must have an initialization expression, which need not be a constant expression. The variable initializer is evaluated and the assignment performed exactly once, when the interface is initialized.

Database : SQL to find reference tables


To find all tables that referenced “Organization” table use the following SQL query:

select table_name, constraint_name, status from user_constraints
where constraint_type = ‘R’
and r_constraint_name in
select constraint_name from user_constraints
where constraint_type in (‘P’, ‘U’)
and table_name = ‘ORGANIZATION’
order by table_name, constraint_name;

NOTE: In the query above ‘ORGANIZATION’ can be replaced with the name of any table you are interested in.


TestNG : Expected Exception Test

It is always good to test the working and output of your unit. But it is more important to test the negative behavior to make application robust. What if you are expecting an exception from a part of code which is not thrown. the point where application has to get terminated, it is moving smoothly to get a dead lock or a pitty crash. Just to save such situation Testing of exception generation is code is very important. There are annotation in TestNG frame work which helps to make is an easy task.


import org.testng.annotations.*;

public class TestNGTest2 {

	@Test(expectedExceptions = ArithmeticException.class)  
	public void divisionWithException() {  
	  int i = 1/0;


In above example, the divisionWithException() method will throw an ArithmeticException Exception, since this is an expected exception, so the unit test will pass.

More advanced example can be observed in the snap shot attached.
Where the scenarios to test says – “Calling this method with null argument throws Exception”.
The test will go green if exception is thrown, else it will go red.

Testing the expected exception

Testing the expected exception

Hibernate : How to Use Enum


By default Hibernate persists the enumeration value as integer in the database when type param is not specified, In order to store the enum display name, we use a param type, which should be pointed to value in java.sql. Instead of leaving the input open it is a better practice to confine the possible input values in the form of enum. For example, A product can have limited number of state like available, out of stock etc. If we will leave the input out open there are chances of confusion causing data errors eventually. However, if we create the input enum then, changes of data error becomes less.
The details is mentined in the diagram attached.

Java class showing usage of enum

Java class showing usage of enum


You might be curious to know how would it persist in the Database table. Below snap shot explains it. Please care of the comments mentioned in the diagrams.

Table view of Enum persisted from Hibernate entity

Table view of Enum persisted from Hibernate entity