Course Contents for JAVA For a Begginer

Introduction to Java Programming► Advantages of Java • Platform independence • Stand-alone applications and servlets► Structure of a Java program • Compiling source code into byte code • Overview of class libraries --------------------------------------------------------------------------------------------------------------------------------------------------------Object-Oriented Programming with Java► The object paradigm • Object-oriented (OO) programming • Encapsulation, inheritance and polymorphism • OO analysis and design: "Is a" and "Has a" relationships • Designing an OO application step by step • Diagramming object structure with Unified Modeling Language (UML)► Java's object-oriented features • Instantiating objects from classes • Aggregation and composition • Extending existing classes • Overloading and overriding methods --------------------------------------------------------------------------------------------------------------------------------------------------------Structure of the Java Language► Language syntax • Declaring and initializing variables • Statements and expressions

• Declaring and using arrays • Up casting, down casting and auto boxing► Flow control • Invoking methods and passing parameters • Conditionals and loops • Handling exceptions with try and catch► Defining classes • Fields (instance data) • Methods (functions) • Abstract classes and interfaces • Organizing classes with packages and visibility modifiers • Composition vs. inheritance► Building the components of a Java program • Working with existing classes • Leveraging generics with the collections API • Extending base classes • Developing new classes • Compiling and debugging --------------------------------------------------------------------------------------------------------------------------------------------------------Developing GUIs► Foundations of user interfaces • Basic GUI widgets • Event-driven programming • Benefits of a portable windowing library

► Java Foundation Classes (JFC) • Advantages of lightweight Swing components • Exploring the Swing component library • Creating Swing components: buttons, text fields, drop-down lists • Adding Swing components to containers

• Arranging Swing components using layout managers • Dialogs and message boxes► Event handling • Registering event handlers • Inner classes and top-level classes --------------------------------------------------------------------------------------------------------------------------------------------------------Storing and Retrieving Data with File I/O► Java streams • Streams, Readers and Writers • Accessing files • Catching and throwing exceptions • Formatting text output► Files and directories • Reading and writing files • Creating, deleting and renaming files • Obtaining directory and file information --------------------------------------------------------------------------------------------------------------------------------------------------------Working with Relational Databases► JDBC database access • Leveraging the JDBC API • Choosing database drivers • Connecting to a database

► Improving performance with prepared statements and stored procedures • Submitting SQL statements • Retrieving and processing results --------------------------------------------------------------------------------------------------------------------------------------------------------Java Development Tools • Java Development Kit (JDK)

• Compiler (java c) • Java doc utility • Java Archive (JAR) utility • Java Integrated Development Environments (Ides) --------------------------------------------------------------------------------------------------------------------------------------------------------Introduction and Overview► Web application development • The requirements of a Web application • Components of an n-tier architecture► Key components of Java EE for Web development • Servlets • JSP • XML --------------------------------------------------------------------------------------------------------------------------------------------------------Generating Content with Servlets► Getting started with servlets • Integrating servlets into the Web application architecture • Configuring the servlet development environment • Avoiding common servlet pitfalls

► Utilizing the Java Servlet API • Servlet life cycle methods • Accessing servlet environment variables► Creating Web-based forms for user input • Adding text fields and drop-down lists • Linking forms to servlets • Retrieving form data in the servlet--------------------------------------------------------------------------------------------------------------------------------------------------------Accessing databases with Servlets► Extending servlets with Java Database Connectivity (JDBC)

• Connecting to the database • Submitting SQL statements • Retrieving and processing data • Formatting database results • Constructing an HTML table • Adding drill-down features --------------------------------------------------------------------------------------------------------------------------------------------------------Maintaining State in Java Web Applications► Reading and writing cookies to personalize Web content • Retrieving cookies from a client request • Sending cookies to the client • Circumventing cookie limitations ► Managing application state with sessions • Creating a unique session for each user • Storing and retrieving Java objects within sessions • Controlling a session's life span • Creating application and session event listeners Implementing a shopping cart --------------------------------------------------------------------------------------------------------------------------------------------------------Creating Java Server Pages (JSP)► JSP fundamentals • Design goals of JSP • Using JSP script lets, expressions and declarations • Communicating with the client using built-in JSP server objects • Leveraging the JSP 2 Expression Language (EL) ► State management with JSP • Accessing cookies and sessions • Storing common application data --------------------------------------------------------------------------------------------------------------------------------------------------------

Designing JSP and Servlet Architectures► Integrating JSP and JavaBeans • Promoting object reuse • Separating application logic from the presentation ► Calling JSP from servlets • Forwarding Java objects to JSP • Using JavaBeans to transfer data • Servlet and JSP design patterns --------------------------------------------------------------------------------------------------------------------------------------------------------Integrating JSP Custom Tags► Leveraging the Tag Extension mechanism • The role of JSP custom tags • Applying the JSP Standard Tag Library (JSTL)► Developing custom tags • Creating custom tags with JSP 2 tag files • Customizing tag behavior with attributes --------------------------------------------------------------------------------------------------------------------------------------------------------Developing Struts Application► Struts 1 framework overview • Components of the Struts framework • Model-View-Controller (MVC) architecture► Developing Struts components • Building the JavaBeans model • Presenting a view with JSP • Dispatching actions with the controller --------------------------------------------------------------------------------------------------------------------------------------------------------Deploying Your Java Web Application • Defining the deployment descriptor • Creating a Web Application Archive (WAR) file • Adding role-based application secu

► Launching a Struts 2 application • Defining the need for a Struts 2 architecture • Specifying the application structure • Preparing the development environment► Getting started with Struts 2 • Identifying key application components • Implementing the request processing cycle • Linking the flow by configurations --------------------------------------------------------------------------------------------------------------------------------------------------------Configuring Struts 2► Actions, results and interceptors • Categorizing requests with namespaces and packages • Exploiting zero configuration conventions► Setting the default features • Inspecting out of the box functionality • Building dependencies with Inversion of Control --------------------------------------------------------------------------------------------------------------------------------------------------------Implementing Struts 2 Actions► Controlling application flow • Utilizing the Action Support base class • Eliminating redundant code with Model Driven actions► Simplifying the development process • Best practices for unit testing your actions • Improving maintainability through message localization --------------------------------------------------------------------------------------------------------------------------------------------------------Gathering and Validating User Input► Building Struts 2 views • Defining an improved approach to page generation with Struts 2 tags • Leveraging the Struts 2 On-Demand model for data

access • Gathering user data effortlessly • Controlling page flow with model data► Struts 2 validation architecture • Positioning the Struts 2 validation model • Exploring the built-in validation rules • Applying validation interceptors • Efficiently handling validation failures► Extending the validation framework • Creating your own validation rules • Configuring validation through Struts 2 annotations • Integrating custom validation with built-in rules--------------------------------------------------------------------------------------------------------------------------------------------------------

Enterprise Web Application Development • Design goals of a Web application • Components of an enterprise architectureStruts Fundamentals► Getting started with Struts • Installing and configuring Struts • Identifying Struts core classes • Integrating Struts Custom Tag Libraries► Struts development process • Analyzing application flow • Building the JavaBeans model • Presenting a view with JSP • Dispatching actions with the controller --------------------------------------------------------------------------------------------------------------------------------------------------------Handling Application Requests► Defining Action Classes • Configuring the Struts Controller

• Processing requests with Actions • Managing application state • Forwarding business data to JSP view components► Processing HTML forms • Defining Action Form beans • Populating Action Forms with form data • Creating wizard-style page flows • Preventing duplicate form submission • Allowing file uploads► Integrating business logic with Java EE design patterns • Decoupling the business tier using the Business Delegate pattern • Transferring data using the Value Object pattern► Advanced controller features • Leveraging pre-defined Struts Actions • Handling exceptions: declarative and programmatic approaches • Extending Struts with Plug-Ins • Creating a custom Request Processor --------------------------------------------------------------------------------------------------------------------------------------------------------Generating Dynamic Views► Integrating JSP custom tags • Custom tag usage model • Configuring tag libraries► Building Struts views • Handling data input with Struts HTML tags • Generating output with Struts Bean tags • Manipulating Object graphs with Struts Nested tags► Streamlining JSP development • Defining JSTL functionality • Formatting output using JSTL-EL • Controlling page content using JSTL logic tags

► Internationalizing applications • Translating views to multiple languages • Integrating resource bundles with Struts • Changing locale on the fly

TOP--------------------------------------------------------------------------------------------------------------------------------------------------------

Java Server Faces • Creating views with JSF components • Faces request processing life cycle • Comparing Struts and JSFMoving Forward with Struts 2 • Analyzing the enhanced features of Struts 2 • Comparing and contrasting Struts 1 and Struts 2 Enterprise Application Development • Establishing the components of an enterprise architecture • Streamlining the development process with Java EE 5Leveraging Java Server Faces (JSF)► JSF architecture • Identifying the JSF core components • Exploring the request processing cycle • Managing application flow using the JSF navigation model► Constructing a JSF application • Creating views with JSF custom tags • Handling user events with backing beans► Enhancing functionality using JSF services • Applying server-side data validation

• Taking advantage of the Unified Expression Language --------------------------------------------------------------------------------------------------------------------------------------------------------

Generating Rich User Interfaces (UI) with JSF Component Technology► Building views with standard HTML components • Defining the functionality of the HTML component set • Arranging the UI component layout • Localizing messages using Resource Bundles ► Creating custom UI components • Developing the custom component class • Writing the custom tag handler • Deploying the custom component ► Leveraging Ajax to improve the user experience • Sharpening response with the asynchronous Web model

• Combining Ajax functionality with JSF • Utilizing pre-built Ajax-enabled JSF components--------------------------------------------------------------------------------------------------------------------------------------------------------

Implementing the Business Tier with EJB 3 ► Stateless and stateful beans • Encapsulating scalable business logic with JavaBeans • Accessing session beans remotely • Constructing effective stateful services ► Applying advanced strategies of session beans • Adding behaviors with method interceptors • Linking services with annotation-based resource injection • Triggering timer-based services► Obtaining asynchronous communication with JMS

• Decoupling client interaction with the Java Message Service • Transmitting and receiving messages with JMS► Unleashing Message Driven Beans (MDB) • Simplifying robust message receivers with MDB • Generalizing message reception with Java connectors --------------------------------------------------------------------------------------------------------------------------------------------------------Opening Access with Web Services► Achieving interoperability with JAX-WS • Coding and packaging a service endpoint • Packaging and deploying the service► Accessing services with JAX-WS clients • Analyzing the client contract • Binding and exchanging valid data types Handling Complex Object Relationships► Effectively representing object associations • Capturing single and multi-valued associations • Representing Java collections► Choosing appropriate inheritance strategies • Employing techniques for class-to-database mapping • Auditing operations with Callbacks and Listeners► Working with JPQL • Initiating data access with the Java Persistence Query Language (JPQL) and API • Selecting Entity and relationship properties► Enhancing application structure and performance • Improving structure with named queries • Augmenting JPQL with native optimized SQL --------------------------------------------------------------------------------------------------------------------------------------------------------Overview of XML Technologies► XML in the enterprise

• The benefits of pairing Java and XML • Styling for B2B transformation and B2C presentation► The well-formed XML document • The document root and prolog • Syntax • Namespaces • Content • Elements • Attributes • Entities --------------------------------------------------------------------------------------------------------------------------------------------------------Exchanging and Validating Data► Designing XML enterprise applications • Data modeling with XML • B2B/B2C object modeling for Java • Enforcing validation in data exchange► Writing Document Type Definitions (DTDs) • Embedding business rules into DTDs • DTD syntax and components► XML schemas • Limitations of DTDs • Leveraging Schema Data types • Writing XML to validate XML • Building user-defined types --------------------------------------------------------------------------------------------------------------------------------------------------------DOM Parsing with Java► DOM syntax for Java • Fitting DOM into XML • Extracting data through the DOM tree view • Working with DOM nodes • Processing DOM data

► Validating DOM • Determining when to use validation • Enabling validation in the parser Handling DOM exceptions► Constructing Java objects with DOM • Mapping XML data into Java • Building a user-friendly GUI from DOM --------------------------------------------------------------------------------------------------------------------------------------------------------Generating and Updating XML with DOM► Extracting data with Java Database Connectivity (JDBC) • Establishing the database connection • Querying and modifying a database with SQL► Modifying DOM data • Identifying specific nodes • Restructuring the document tree► Building XML documents from scratch • Generating XML from a JDBC Result Set • Creating element and text nodes • Outputting a document using a Serializer --------------------------------------------------------------------------------------------------------------------------------------------------------Java EE and Design Patterns► Enterprise system design • Comparing OO and Java EE patterns • The benefits of design patterns in Java EE► Distributed systems development • Exploiting remote method invocation • Design patterns in distributed systems --------------------------------------------------------------------------------------------------------------------------------------------------------Structuring the Web Presentation Tier► Separating control and presentation logic

• The role of JSP’s and servlets • Constructing Model View Control (MVC) architectures • Front Controller • Dispatcher View • Service to Worker► Applying Web framework support with Struts • Investigating the Struts MVC architecture • Planning and implementing complex workflows • Handling duplicate form submission with the Synchronizer Token pattern► Localizing disparate logic • Improving maintainability of algorithms • Intercepting Filter • View Helper • Composite View • Reusing page layout with Tiles • Writing modular JSPs