|
Provided by: Software Training Academy, Inc Advanced Java Programming Rev 5 |
 |
This course provides advanced training in developing software using the Java 2 Platform, Standard Edition, or J2SE. It is intended for students with solid experience in structured and object-oriented Java programming, including use of the Collections API and exception handling. The course software also includes an optional overlay of workspace and project files to support use of the Eclipse IDE in the classroom.
The course is organized into five modules. The first covers several general-purpose topics: using Java-5.0 generics, writing multi-threaded applications, the Reflection API and annotations, and network programming using sockets. Then the course takes up the challenge of building multi-tier applications using the standard Java platform. Multi-tier development most frequently uses the Java 2 Platform, Enterprise Edition, or J2EE, and we have a wide range of courses in that area. However it is quite possible to build lightweight multi-tier applications using only J2SE, and for some purposes the J2EE is moure trouble than it?s worth.
So the course looks at each of the traditional tiers and the J2SE APIs most suited to developing them: the Java Foundation Classes, or JFC, for building graphical user interfaces (GUIs) for the presentation tier; Java RMI as a way of distributing Java objects in a separate business tier; and JDBC for the persistence tier. A J2SE multi-tier application provides a comprehensive case study that illustrates multi-tier architecture, design patterns, and best practices, and also provides a few challenge labs. Students will complete the course prepared to build distributed Java applications and to pursue JFC, RMI, or JDBC in greater depth.
LEARNING OBJECTIVES
Make effective use of Java generic types.
Write multi-threaded Java applications.
Use the Reflection API for highly generic tasks, discovery, or code-generation.
Use standard annotations and develop custom annotations to express meta-data in Java source files.
Communicate between processes using network sockets.
Understand the roles of JFC, RMI, JDBC, and other Core API packages in the classic multi-tier architecture for distributed systems.
Understand the basics of the JFC architecture.
Build complex GUIs using various JFC controls.
Understand the relationship between RMI and various J2EE technologies such as JNDI, EJB, and CORBA.
Implement simple RMI clients and servers.
Connect to a database using JDBC and perform a simple query.
Update relational data using JDBC to execute updates, inserts and deletes.
Use prepared statements to produce reusable database queries and optimize execution time.
Use callable statements to access database procedures.
Use scrollable and updatable results sets for more robust solutions.
Use commit, rollback, and savepoint to build transactional systems.
Use batch processing for efficient handling of large datasets.
Use the Java 5.0 Core API and related tools to develop robust multi-tier applications.
Duration: 5 days.
Prerequisites: Students must be experienced Java programmers, able to build, test, and debug complex applications using structured and object-oriented code designs, and familiar with the Collections API and Java exception-handling. Either of STA?s Courses 103 or 104 would be excellent preparation.
The course is organized into five modules. The first covers several general-purpose topics: using Java-5.0 generics, writing multi-threaded applications, the Reflection API and annotations, and network programming using sockets. Then the course takes up the challenge of building multi-tier applications using the standard Java platform. Multi-tier development most frequently uses the Java 2 Platform, Enterprise Edition, or J2EE, and we have a wide range of courses in that area. However it is quite possible to build lightweight multi-tier applications using only J2SE, and for some purposes the J2EE is moure trouble than it?s worth.
So the course looks at each of the traditional tiers and the J2SE APIs most suited to developing them: the Java Foundation Classes, or JFC, for building graphical user interfaces (GUIs) for the presentation tier; Java RMI as a way of distributing Java objects in a separate business tier; and JDBC for the persistence tier. A J2SE multi-tier application provides a comprehensive case study that illustrates multi-tier architecture, design patterns, and best practices, and also provides a few challenge labs. Students will complete the course prepared to build distributed Java applications and to pursue JFC, RMI, or JDBC in greater depth.
LEARNING OBJECTIVES
Make effective use of Java generic types.
Write multi-threaded Java applications.
Use the Reflection API for highly generic tasks, discovery, or code-generation.
Use standard annotations and develop custom annotations to express meta-data in Java source files.
Communicate between processes using network sockets.
Understand the roles of JFC, RMI, JDBC, and other Core API packages in the classic multi-tier architecture for distributed systems.
Understand the basics of the JFC architecture.
Build complex GUIs using various JFC controls.
Understand the relationship between RMI and various J2EE technologies such as JNDI, EJB, and CORBA.
Implement simple RMI clients and servers.
Connect to a database using JDBC and perform a simple query.
Update relational data using JDBC to execute updates, inserts and deletes.
Use prepared statements to produce reusable database queries and optimize execution time.
Use callable statements to access database procedures.
Use scrollable and updatable results sets for more robust solutions.
Use commit, rollback, and savepoint to build transactional systems.
Use batch processing for efficient handling of large datasets.
Use the Java 5.0 Core API and related tools to develop robust multi-tier applications.
Duration: 5 days.
Prerequisites: Students must be experienced Java programmers, able to build, test, and debug complex applications using structured and object-oriented code designs, and familiar with the Collections API and Java exception-handling. Either of STA?s Courses 103 or 104 would be excellent preparation.
|
|
||||||||
Training
Provided by Software Training Academy, Inc
- R asked: I want to know more about CBT e learning course. I would like to do this course.
Advanced Java Programming Rev 5
Module 1. Advanced Java APIs
1. Generics
Using Generics
Type Erasure
Type Boundaries
Wildcards
Generic Methods
Strengths and Weaknesses of Generics
Legacy Code and Generics
2. Threads
Java Thread Model
Creating and Running Threads
Manipulating Thread State
Thread Synchronization
Volatile Fields vs. Synchronized Methods
wait and notify
join and sleep
The Concurrency API
Atomic Operations
3. Reflection
Uses for Meta-Data
The Reflection API
The Class<T> Class
The java.lang.reflect Package
Reading Type Information
Navigating Inheritance Trees
Dynamic Instantiation
Dynamic Invocation
Reflecting on Generics
4. Annotations
Aspect-Oriented Programming and Java
The Annotations Model
Annotation Types and Annotations
Built-In Annotations
Annotations vs. Descriptors (XML)
5. Sockets
The OSI Reference Model
Network Protocols
The Socket Class
The ServerSocket Class
Connecting Through URL Objects
HTTP and Other TCP Servers
Datagram Clients and Servers
Non-Blocking Sockets
Module 2. J2SE Multi-Tier Case Study
1. Overview
Three Tiers for J2EE
Three Tiers for J2SE
The Case Study
Design Patterns
Domain and Service Models
2. The Presentation Tier
The Standalone/Client Application
JDesktopPane and JinternalFrame
Adapting JList, JTable, and JTree to Services
Presentation-Tier Patterns
3. The Business Tier
Distributing the Application
A Chain of Services
Logging
Business-Tier Patterns
Designing for Latency
4. The Persistence Tier
A Database is Not a Persistence Tier
Persistence Frameworks
Persistent-Object Strategies
Persistence-Tier Patterns
Caching
Module 3. The Java Foundation Classes
5. Introduction to JFC
Abstract Windowing Toolkit Basics
Simple Layout Management
Simple Event Handling
Lightweight Controls
JFC Feature Set
JFC Architecture and Relationship to AWT
6. JFC Application Design
Role of a JFrame
Building a Frame-Based JFC Application
Panes
Using Dialogs
7. JFC Components
JFC Component Class Hierarchy
JComponent Features
Simple Control Types
Text Components
Menus
Managing Look and Feel
Module 4. Java Remote Method Invocation
1. RMI Architecture
Motivation for RMI
RMI, EJB, and CORBA
RMI Architecture
Lifetime of a Remote Method Invocation
Registries
Naming and URL Resolution
Interface Design
The Remote Interface
Implementation Classes
The RemoteObject and RemoteServer Classes
The UnicastRemoteObject Class
Server Implementation
Using the Registry
Client Implementation
Code Deployment
2. Practical RMI
RMI Marshaling
Passing Objects
The Factory Pattern
Serialization vs. Remote Reference
Designing for Latency
The Transfer Object Pattern
Controlling Object Location
Exception Handling
Module 5. Java Database Connectivity
1. Database and SQL Fundamentals
Relational Databases and SQL
Database, Schema, Tables, Columns and Rows
SQL Versions and Vendor Implementations
DDL ? Creating and Managing Database Objects
DML ? Retrieving and Managing Data
Sequences
Stored Procedures
Using SQL Terminals
2. JDBC Fundamentals
What is the JDBC API?
JDBC Drivers
Making a Connection
Creating and Executing a Statement
Retrieving Values from a ResultSet
SQL and Java Datatypes
Creating and Updating Tables
Handling SQL Exceptions and Proper Cleanup
Handling SQLWarning
3. Advanced JDBC
SQL Escape Syntax
Using Prepared Statements
Using Callable Statements
Scrollable Result Sets
Updatable Result Sets
Transactions
Commits, Rollbacks, and Savepoints
Batch Processing
4. Introduction to Row Sets
Row Sets in GUI and J2EE programming
Advantages of RowSets
RowSet Specializations
Using CachedRowSets
1. Generics
Using Generics
Type Erasure
Type Boundaries
Wildcards
Generic Methods
Strengths and Weaknesses of Generics
Legacy Code and Generics
2. Threads
Java Thread Model
Creating and Running Threads
Manipulating Thread State
Thread Synchronization
Volatile Fields vs. Synchronized Methods
wait and notify
join and sleep
The Concurrency API
Atomic Operations
3. Reflection
Uses for Meta-Data
The Reflection API
The Class<T> Class
The java.lang.reflect Package
Reading Type Information
Navigating Inheritance Trees
Dynamic Instantiation
Dynamic Invocation
Reflecting on Generics
4. Annotations
Aspect-Oriented Programming and Java
The Annotations Model
Annotation Types and Annotations
Built-In Annotations
Annotations vs. Descriptors (XML)
5. Sockets
The OSI Reference Model
Network Protocols
The Socket Class
The ServerSocket Class
Connecting Through URL Objects
HTTP and Other TCP Servers
Datagram Clients and Servers
Non-Blocking Sockets
Module 2. J2SE Multi-Tier Case Study
1. Overview
Three Tiers for J2EE
Three Tiers for J2SE
The Case Study
Design Patterns
Domain and Service Models
2. The Presentation Tier
The Standalone/Client Application
JDesktopPane and JinternalFrame
Adapting JList, JTable, and JTree to Services
Presentation-Tier Patterns
3. The Business Tier
Distributing the Application
A Chain of Services
Logging
Business-Tier Patterns
Designing for Latency
4. The Persistence Tier
A Database is Not a Persistence Tier
Persistence Frameworks
Persistent-Object Strategies
Persistence-Tier Patterns
Caching
Module 3. The Java Foundation Classes
5. Introduction to JFC
Abstract Windowing Toolkit Basics
Simple Layout Management
Simple Event Handling
Lightweight Controls
JFC Feature Set
JFC Architecture and Relationship to AWT
6. JFC Application Design
Role of a JFrame
Building a Frame-Based JFC Application
Panes
Using Dialogs
7. JFC Components
JFC Component Class Hierarchy
JComponent Features
Simple Control Types
Text Components
Menus
Managing Look and Feel
Module 4. Java Remote Method Invocation
1. RMI Architecture
Motivation for RMI
RMI, EJB, and CORBA
RMI Architecture
Lifetime of a Remote Method Invocation
Registries
Naming and URL Resolution
Interface Design
The Remote Interface
Implementation Classes
The RemoteObject and RemoteServer Classes
The UnicastRemoteObject Class
Server Implementation
Using the Registry
Client Implementation
Code Deployment
2. Practical RMI
RMI Marshaling
Passing Objects
The Factory Pattern
Serialization vs. Remote Reference
Designing for Latency
The Transfer Object Pattern
Controlling Object Location
Exception Handling
Module 5. Java Database Connectivity
1. Database and SQL Fundamentals
Relational Databases and SQL
Database, Schema, Tables, Columns and Rows
SQL Versions and Vendor Implementations
DDL ? Creating and Managing Database Objects
DML ? Retrieving and Managing Data
Sequences
Stored Procedures
Using SQL Terminals
2. JDBC Fundamentals
What is the JDBC API?
JDBC Drivers
Making a Connection
Creating and Executing a Statement
Retrieving Values from a ResultSet
SQL and Java Datatypes
Creating and Updating Tables
Handling SQL Exceptions and Proper Cleanup
Handling SQLWarning
3. Advanced JDBC
SQL Escape Syntax
Using Prepared Statements
Using Callable Statements
Scrollable Result Sets
Updatable Result Sets
Transactions
Commits, Rollbacks, and Savepoints
Batch Processing
4. Introduction to Row Sets
Row Sets in GUI and J2EE programming
Advantages of RowSets
RowSet Specializations
Using CachedRowSets
About The Training Provider: Software Training Academy, Inc
Software Training Academy, Inc - Software Training Academy is company based in Seattle, WA (USA) and Toronto, ON (Canada) and it offers highly customized IT Training.
Our portfolio includes Java, .NET, Web Development (PHP, Ruby on Rails, etc), Databases (Oracle, SQL Server, MySQL, DB2, etc) and Advanced courses for Microsoft Office.
We deliver courses either onsite or in class throughout North America and Europe, and...
