Pondurai Singh

EJB 3.1 technology used in Java EE 6 Enterprise Architect Certification.

Difference between SCBCD 6 and OCE EJB & JPA certifications.
Please refer: http://www.slideshare.net/barathganesh/scbcd-ocpjbcd-oce-ejb-jpa-certifications

Oracle university provide any nothing information related to Java EE 7 certification. Any way you keep continue your preparation. If your become certified not matter you can upgrade to OCEJWCD 7.

And Java EE 7 changes have been made to the certification has following specialities:

Implement the new Java API for Batch Applications, JSON and Websocket in your code(JSRs 352, 353 and 356).

Enable JAX-RS 2.0, EL 3.0 and JMS 2.0 Major enhancements in your code.

Implement the enhancements in JSF and JSP in your code.

Implement the enhancements in CDI and Bean Validation in your code.

Implement the enhancements in EJB and JPA in your code.

Describe and leverage the enhancements in the Java EE 7 platform.

Understand the new features for Java EE 7: JSON, WebSockets, HTML 5, JSF & Servlets.

Update existing applications to EE 7.

Mark Spritzler wrote:Yep, it isn't a Spring issue. It is a Web context location issue.

I bring in my css files like

<link href="${pageContext.request.contextPath}/styles/themes/default.css" rel="stylesheet">

This is putting it at the root of the war file, then going into the /styles…. directory to find the css.

Mark

Correct,
<link href="${pageContext.request.contextPath}/css/main.css" rel="StyleSheet" type="text/css" />

Refer this http://stackoverflow.com/questions/10558966/hibernate-ejb3-1-in-tomcat-what-is-needed-to-make-this-possible both are look like same

Head First Servlets & JSP: Passing the Sun Certified Web Component Developer Exam (second edition) by Bryan Basham, Kathy Sierra, Bert Bates, This book gives you a very good comparison with old web frameworks, it also tries to give the reader a good back ground in good application development architecture. Refer https://coderanch.com/t/93812/Book-Reviews/Head-First-Servlets-JSP-Kathy you can get information about this book.

Example program Sort an array of ASCII strings into ascending order
Reference: oreilly.com/9781565923713/
// Copyright (c) 1997 by David Flanagan // These are some classes we need for internationalized string sorting import java.text.Collator; import java.text.CollationKey; import java.util.Locale; /** * This class defines a bunch of static methods for efficiently sorting * arrays of Strings or other objects. It also defines two interfaces that * provide two different ways of comparing objects to be sorted. **/ public class Sorter { /** * This interface defines the compare() method used to compare two objects. * To sort objects of a given type, you must provide an appropriate Comparer * object with a compare() method that orders those objects as desired **/ public static interface Comparer { /** * Compare objects and return a value that indicates their relative order: * if (a > b) return > 0; * if (a == b) return 0; * if (a < b) return < 0. **/ public int compare(Object a, Object b); } /** * This is an alternative interface that can be used to order objects. If a * class implements this Comparable interface, then any two instances of that * class can be directly compared by invoking the compareTo() method. **/ public static interface Comparable { /** * Compare objects and return a value that indicates their relative order: * if (this > other) return > 0 * if (this == other) return 0 * if (this < other) return < 0 **/ public int compareTo(Object other); } /** * This is an internal Comparer object (created with an anonymous class) * that compares two ASCII strings. * It is used in the sortAscii methods below. **/ private static Comparer ascii_comparer = new Comparer() { public int compare(Object a, Object b) { return ((String)a).compareTo((String)b); } }; /** * This is another internal Comparer object. It is used to compare two * Comparable objects. It is used by the sort() methods below that take * Comparable objects as arguments instead of arbitrary objects */ private static Comparer comparable_comparer = new Comparer() { public int compare(Object a, Object b) { return ((Comparable)a).compareTo(b); } }; /** Sort an array of ASCII strings into ascending order */ public static void sortAscii(String[] a) { // Note use of the ascii_comparer object sort(a, null, 0, a.length-1, true, ascii_comparer); } /** * Sort a portion of an array of ASCII strings into ascending or descending * order, depending on the argument up **/ public static void sortAscii(String[] a, int from, int to, boolean up) { // Note use of the ascii_comparer object sort(a, null, from, to, up, ascii_comparer); } /** Sort an array of ASCII strings into ascending order, ignoring case */ public static void sortAsciiIgnoreCase(String[] a) { sortAsciiIgnoreCase(a, 0, a.length-1, true); } /** * Sort an portion of an array of ASCII strings, ignoring case. Sort into * ascending order if up is true, otherwise sort into descending order. **/ public static void sortAsciiIgnoreCase(String[] a, int from, int to, boolean up) { if ((a == null) || (a.length < 2)) return; // Create a secondary array of strings that contains lowercase versions // of all the specified strings. String b[] = new String[a.length]; for(int i = 0; i < a.length; i++) b[i] = a[i].toLowerCase(); // Sort that secondary array, and rearrange the original array // in exactly the same way, resulting in a case-insensitive sort. // Note the use of the ascii_comparer object sort(b, a, from, to, up, ascii_comparer); } /** * Sort an array of strings into ascending order, using the correct * collation order for the default locale **/ public static void sort(String[] a) { sort(a, 0, a.length-1, true, false, null); } /** * Sort a portion of an array of strings, using the collation order of * the default locale. If up is true, sort ascending, otherwise, sort * descending. If ignorecase is true, ignore the capitalization of letters **/ public static void sort(String[] a, int from, int to, boolean up, boolean ignorecase) { sort(a, from, to, up, ignorecase, null); } /** * Sort a portion of an array of strings, using the collation order of * the specified locale. If up is true, sort ascending, otherwise, sort * descending. If ignorecase is true, ignore the capitalization of letters **/ public static void sort(String[] a, int from, int to, boolean up, boolean ignorecase, Locale locale) { // Don't sort if we don't have to if ((a == null) || (a.length < 2)) return; // The java.text.Collator object does internationalized string compares // Create one for the specified, or the default locale. Collator c; if (locale == null) c = Collator.getInstance(); else c = Collator.getInstance(locale); // Specify whether or not case should be taken into account in the sort. // Note: this option does not seem to work correctly in JDK 1.1.1 // using the default American English locale. if (ignorecase) c.setStrength(Collator.SECONDARY); // Use the Collator object to create an array of CollationKey objects that // correspond to each of the strings. // Comparing CollationKeys is much quicker than comparing Strings CollationKey[] b = new CollationKey[a.length]; for(int i = 0; i < a.length; i++) b[i] = c.getCollationKey(a[i]); // Now define a Comparer object to compare collation keys, using an // anonymous class. Comparer comp = new Comparer() { public int compare(Object a, Object b) { return ((CollationKey)a).compareTo((CollationKey)b); } }; // Finally, sort the array of CollationKey objects, rearranging the // original array of strings in exactly the same way. sort(b, a, from, to, up, comp); } /** Sort an array of Comparable objects into ascending order */ public static void sort(Comparable[] a) { sort(a, null, 0, a.length-1, true); } /** * Sort a portion of an array of Comparable objects. If up is true, * sort into ascending order, otherwise sort into descending order. **/ public static void sort(Comparable[] a, int from, int to, boolean up) { sort(a, null, from, to, up, comparable_comparer); } /** * Sort a portion of array a of Comparable objects. If up is true, * sort into ascending order, otherwise sort into descending order. * Re-arrange the array b in exactly the same way as a. **/ public static void sort(Comparable[] a, Object[] b, int from, int to, boolean up) { sort(a, b, from, to, up, comparable_comparer); } /** * Sort an array of arbitrary objects into ascending order, using the * comparison defined by the Comparer object c **/ public static void sort(Object[] a, Comparer c) { sort(a, null, 0, a.length-1, true, c); } /** * Sort a portion of an array of objects, using the comparison defined by * the Comparer object c. If up is true, sort into ascending order, * otherwise sort into descending order. **/ public static void sort(Object[] a, int from,int to, boolean up, Comparer c){ sort(a, null, from, to, up, c); } /** * This is the main sort() routine. It performs a quicksort on the elements * of array a between the element from and the element to. The up argument * specifies whether the elements should be sorted into ascending (true) or * descending (false) order. The Comparer argument c is used to perform * comparisons between elements of the array. The elements of the array b * are reordered in exactly the same way as the elements of array a are. **/ public static void sort(Object[] a, Object[] b, int from, int to, boolean up, Comparer c) { // If there is nothing to sort, return if ((a == null) || (a.length < 2)) return; // This is the basic quicksort algorithm, stripped of frills that can make // it faster but even more confusing than it already is. You should // understand what the code does, but don't have to understand just // why it is guaranteed to sort the array... // Note the use of the compare() method of the Comparer object. int i = from, j = to; Object center = a[(from + to) / 2]; do { if (up) { // an ascending sort while((i < to) && (c.compare(center, a[i]) > 0)) i++; while((j > from) && (c.compare(center, a[j]) < 0)) j--; } else { // a descending sort while((i < to) && (c.compare(center, a[i]) < 0)) i++; while((j > from) && (c.compare(center, a[j]) > 0)) j--; } if (i < j) { Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; // swap elements if (b != null) { tmp = b[i]; b[i] = b[j]; b[j] = tmp; }// swap b, too } if (i <= j) { i++; j--; } } while(i <= j); if (from < j) sort(a, b, from, j, up, c); // recursively sort the rest if (i < to) sort(a, b, i, to, up, c); } /** * This nested class defines a test program that demonstrates several * ways to use the Sorter class to sort ComplexNumber objects **/ public static class Test { /** * This subclass of ComplexNumber implements the Comparable interface * and defines a compareTo() method for comparing complex numbers. * It compares numbers based on their magnitude. I.e. on their distance * from the origin. **/ static class SortableComplexNumber extends ComplexNumber implements Sorter.Comparable { public SortableComplexNumber(double x, double y) { super(x, y); } public int compareTo(Object other) { return sign(this.magnitude()-((ComplexNumber)other).magnitude()); } } /** This is the test program. It sorts complex numbers in various ways. */ public static void main(String[] args) { // Define an array of SortableComplexNumber objects. Initialize it // to contain random complex numbers. SortableComplexNumber[] a = new SortableComplexNumber[5]; for(int i = 0; i < a.length; i++) a[i] = new SortableComplexNumber(Math.random()*10, Math.random()*10); // Now sort it using the SortableComplexNumber compareTo() method, which // sorts by magnitude, and print the results out. System.out.println("Sorted by magnitude:"); Sorter.sort(a); for(int i = 0; i < a.length; i++) System.out.println(a[i]); // Sort the complex numbers again, using a Comparer object that // compares them based on the sum of their real and imaginary parts System.out.println("Sorted by sum of real and imaginary parts:"); Sorter.sort(a, new Sorter.Comparer() { public int compare(Object a, Object b) { ComplexNumber i = (ComplexNumber)a, j = (ComplexNumber)b; return sign((i.real() + i.imaginary()) - (j.real() + j.imaginary())); } }); for(int i = 0; i < a.length; i++) System.out.println(a[i]); // Sort them again using a Comparer object that compares their real // parts, and then their imaginary parts System.out.println("Sorted descending by real part, then imaginary:"); Sorter.sort(a, 0, a.length-1, false, new Sorter.Comparer() { public int compare(Object a, Object b) { ComplexNumber i = (ComplexNumber) a, j = (ComplexNumber) b; double result = i.real() - j.real(); if (result == 0) result = i.imaginary() - j.imaginary(); return sign(result); } }); for(int i = 0; i < a.length; i++) System.out.println(a[i]); } /** This is a convenience routine used by comparison routines */ public static int sign(double x) { if (x > 0) return 1; else if (x < 0) return -1; else return 0; } } }

Following article helps you to create you own drop down menu.
queness.com/post/1047/easy-to-style-jquery-drop-down-menu-tutorial
wabism.com/jquery-drop-down-menu-tutorial/
smashingapps.com/2012/04/05/15-handpicked-jquery-drop-down-menus-tutorials.html
webchief.co.uk/blog/simple-jquery-dropdown-menu/index.php
kriesi.at/archives/create-a-multilevel-dropdown-menu-with-css-and-improve-it-via-jquery
designreviver.com/tutorials/jquery-css-example-dropdown-menu/

Refer this coding koders.com/java/fid9B9AFD404F84FAC896DDA0D666A5DBB050E9724D.aspx. In this code binding method witch constructs an UIComponent Tree for JSF page and also Used for dynamic dataTable facility. That will helps you.

Are you getting any error in tomcat console log?
Check is your tomcat server started properly?
Once again deploy your project to server, start the server.

Daniel Negut wrote:You probably have the CLASSPATH environment variable defined (and the test folder is not included).

Question 11 assumes that there is no CLASSPATH environment variable defined.

Ref: coderanch.com/t/270643/java-programmer-SCJP/certification/Error-Sun-Certified-Programmer-Java

Hi Janki Shah,
My opinion is SCWCD may be the right choice. Good luck and Make the correct decisions (for whatever you choose). And congratulations on passing the OCPJP certification exam.

class SIB { public static void main(String punnu[]) { B b1 = new B(); //Here we create Object reference variable b1 for B Class //But class B extends A // Here derived class B inherits base class A's public methods and public data //Now A is loaded, In class A class A { static{System.out.println(1);} // static {..} is static initialization block. //This static initi block Executed once when the class is loaded
So it prints 1
//after inherits base class now Class B is loaded, In class B class B { static{System.out.println(2);}
So it prints 2.
//When create objects reference variable that invoke the constructor of the class, But class B extends A //so it invoke Class A constructor, But Class A has {System.out.println("hi");} // it is an Anonymous code block //It is an alternative to a constructor
So it prints Hi.
//Now Class B constructor invoked B() { System.out.println(3); }
So it prints 3.
A a1 = new A(); //Here we create Object reference variable a1 for Class A //Class A constructor invoked (her Anonymous code block) {System.out.println("hi");}
So it prints Hi.

Note:static initi block Executed once when the class is loaded

New features Java 7
Additional features Java 7- en.wikipedia.org/wiki/Java_version_history#Java_SE_7_.28July_07.2C_2011.29,
Difference between Java SE 6 and Java SE 7 Programmer certification- http://www.epractizelabs.com/blog2/?p=522,
Java SE 7 New Features and Enhancements- oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html,
JDK 7 Features- openjdk.java.net/projects/jdk7/features/,
A look at Java 7's new features- radar.oreilly.com/2011/09/java7-features.html,
New Java 7 Language Features- java.dzone.com/articles/new-java-7-language-features,
7 new cool features in Java 7- sellmic.com/blog/2011/07/08/7-new-cool-features-in-java-7/.

JSF 2.0 hello world example This tutorial show you how to develop a JavaServer Faces (JSF) 2.0 hello world example, shows list of JSF 2.0 dependencies, basic annotations and configurations. mkyong.com/jsf2/jsf-2-0-hello-world-example/