Java Inner Class

/*
*
*
*/
package com.blx.learn.java.core.innerclass;

/**
* This is an example Java Inner class which demonstrate various Inner classes
* available
*
* @author Nanjundan Chinnasamy
* @version 1.0
*
*/
public class LearnInnerClass {

/**
* This is a sample Member Inner class defined inside a class
*
* This inner class is instance specific to the outer class
* (LearnInnerClass). Object can be created for this class using Outer class
* object.
*
* @author Nanjundan Chinnasamy
* @version 1.0
*/
class MemberInnerClass {

/**
* Member class method
*/
public void testMethod() {
System.out.println("This is member class testMethod method");
}

/**
* Static class method
*/
public void memberlassMthd() {
// To access member class method
this.testMethod();
// To access outer class method
LearnInnerClass.this.testMethod();
}
}

/**
* This is a sample Static Member Inner class defined inside a class. Member
* class defined as static. Like other static methods, member class has
* access to all.
*
* @author Nanjundan Chinnasamy
* @version 1.0
*
*/
static class StaticMemberInnerClass {

/**
* Static class method
*/
public void testMethod() {
System.out.println("This is static class testMethod method");
}

/**
* Static class method
*/
public void staticMemClassMthd() {
this.testMethod();
}

}

/**
* Method to testMethod local Inner class
*/
void localClassMethod() {

/**
* This is local class exists inside the method. This can be reference
* only within this method.
*
* @author Nanjundan Chinnasamy
* @version 1.0
*
*/
class LocalInnerClass {
public void testMethod() {
System.out.println("This is local class testMethod mthod.");
}
}
// To access local class methods
new LocalInnerClass().testMethod();
// To access outer class methods
testMethod();

}

/**
* Method to testMethod anonymous inner class
*
*/
void anonymousClassMethod() {

/**
* Anonymous Inner class declared inside a method without any name. JVM
* will create its own name during the compile time.
*
* Such implementation might required the places where to create an
* object instances w/o creating sub class and override their methods
*
* @author Nanjundan Chinnasamy
*
* @version 1.0
*/
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("This is anonymous inner class");
}
};
Thread thread = new Thread(runnable);
thread.run();
}

/**
* This is an out class testMethod method
*/
void testMethod() {
System.out.println("I am outer class testMethod method");
}

/**
* @param args
*/
public static void main(String[] args) {

// This is for static member class
LearnInnerClass.StaticMemberInnerClass staticMemberInnerClass = new StaticMemberInnerClass();
staticMemberInnerClass.staticMemClassMthd();

// This is for member class
MemberInnerClass memberInnerClass = new LearnInnerClass().new MemberInnerClass();
memberInnerClass.testMethod();

// This is for Local Inner class
LearnInnerClass outerClassForLocInnTst = new LearnInnerClass();
outerClassForLocInnTst.localClassMethod();

// This is for anonymous inner class
LearnInnerClass outerClassForAnomysClassTst = new LearnInnerClass();
outerClassForAnomysClassTst.anonymousClassMethod();

}

}


Output:
This is static class testMethod method
This is member class testMethod method
This is local class testMethod mthod.
I am outer class testMethod method
This is anonymous inner class

Way to Prevent Duplicate Request from Form in J2EE applications -2

Guys,

Here is the another solution to prevent duplicate form submission issue in web applications irrespective of the framework implementation.

Can you please try with the below code and update me in comments?

In JSP, we can have java script method during onsubmit like below.

And our java script implementation would be like below. submitForm method return true only very first time and form will be submitted. The same will be true for the sub sequent requests. Hope this will solve our issue.

//Global variable
var submitFlag = 1;

//Submit form method
function submitForm(form) {
if ( submitFlag == 1 ) {

submitFlag = 2;
return true;

} else {
return false;

}
}

Thanks,

-Nanjundan Chinnasamy

Way to Prevent Duplicate Request from Form in J2EE applications -1

Way to Prevent Duplicate Request from Form:

Here is the common and widely used mechanism used to preventing duplication form submission from a j2ee application. Ie, disabling the submit button during on click event. Example here is ICICI bank Internet banking application.

Though this is simple and a reasonable approach if we have a single submit button within a form, this may not work if we have more than one submit buttons in a form.

Are you looking for any other simple strategy to prevent duplication form submission from client side? Follow the next blog.

Cheers,

-Nanjundan Chinnasamy