| Sign in | Sitemap | Feedback
Go To AppexTech

Advanced Java Programming

1 Hour Daily

Duration:- ... Months

Java Training Overview

Appextech's Advanced Java™ Programming training course teaches Java developers the latest advanced Java language skills, including generics, annotations, threads, reflections, sockets, RMI, the Java Foundation Classes, and JDBC.

Java Training Objectives

  1. Write multi-threaded Java applications.
  2. Use the Reflection API for highly generic tasks, discovery, or code-generation.
  3. Use standard annotations and develop custom annotations to express meta-data in Java source files.
  4. Communicate between processes using network sockets.
  5. Understand the roles of JFC, RMI, JDBC, and other Core API packages in the classic multi-tier architecture for distributed systems.
  6. Understand the basics of the JFC architecture.
  7. Build complex GUIs using various JFC controls.
  8. Understand the relationship between RMI and various J2EE technologies such as JNDI, EJB, and CORBA.
  9. Implement simple RMI clients and servers.
  10. Connect to a database using JDBC and perform a simple query.
  11. Update relational data using JDBC to execute updates, inserts and deletes.
  12. Use prepared statements to produce reusable database queries and optimize execution time.
  13. Use callable statements to access database procedures.
  14. Use scrollable and updatable results sets for more robust solutions.
  15. Use commit, rollback, and savepoint to build transactional systems.
  16. Use batch processing for efficient handling of large datasets.
  17. Use the Java 5.0 Core API and related tools to develop robust multi-tier applications.

Java Training Outline

  1. Generics
    1. Using Generics
    2. Type Erasure
    3. Type Boundaries
    4. Wildcards
    5. Generic Methods
    6. Strengths and Weaknesses of Generics
    7. Legacy Code and Generics
  2. Threads
    1. Java Thread Model
    2. Creating and Running Threads
    3. Manipulating Thread State
    4. Thread Synchronization
    5. Volatile Fields vs. Synchronized Methods
    6. wait and notify
    7. join and sleep
    8. The Concurrency API
    9. Atomic Operations
  3. Reflection
    1. Uses for Meta-Data
    2. The Reflection API
    3. The Class<T> Class
    4. The java.lang.reflect Package
    5. Reading Type Information
    6. Navigating Inheritance Trees
    7. Dynamic Instantiation
    8. Dynamic Invocation
    9. Reflecting on Generics
  4. Annotations
    1. Aspect-Oriented Programming and Java
    2. The Annotations Model
    3. Annotation Types and Annotations
    4. Built-In Annotations
    5. Annotations vs. Descriptors (XML)
  5. Sockets
    1. The OSI Reference Model
    2. Network Protocols
    3. The Socket Class
    4. The ServerSocket Class
    5. Connecting Through URL Objects
    6. HTTP and Other TCP Servers
    7. Datagram Clients and Servers
    8. Non-Blocking Sockets
  6. Overview
    1. Three Tiers for J2EE
    2. Three Tiers for J2SE
    3. The Case Study
    4. Design Patterns
    5. Domain and Service Models
  7. The Presentation Tier
    1. The Standalone/Client Application
    2. JDesktopPane and JinternalFrame
    3. Adapting JList, JTable, and JTree to Services
    4. Presentation-Tier Patterns
  8. The Business Tier
    1. Distributing the Application
    2. A Chain of Services
    3. Logging
    4. Business-Tier Patterns
    5. Designing for Latency
  9. The Persistence Tier
    1. A Database is Not a Persistence Tier!
    2. Persistence Frameworks
    3. Persistent-Object Strategies
    4. Persistence-Tier Patterns
    5. Caching
  10. Introduction to JFC
    1. Abstract Windowing Toolkit Basics
    2. Simple Layout Management
    3. Simple Event Handling
    4. Lightweight Controls
    5. JFC Feature Set
    6. JFC Architecture and Relationship to AWT
  11. JFC Application Design
    1. Role of a JFrame
    2. Building a Frame-Based JFC Application
    3. Panes
    4. Using Dialogs
  12. JFC Components
    1. JFC Component Class Hierarchy
    2. JComponent Features
    3. Simple Control Types
    4. Text Components
    5. Menus
    6. Managing Look and Feel
  13. RMI Architecture
    1. Motivation for RMI
    2. RMI, EJB, and CORBA
    3. RMI Architecture
    4. Lifetime of a Remote Method Invocation
    5. Registries
    6. Naming and URL Resolution
    7. Interface Design
    8. The Remote Interface
    9. Implementation Classes
    10. The RemoteObject and RemoteServer Classes
    11. The UnicastRemoteObject Class
    12. Server Implementation
    13. Using the Registry
    14. Client Implementation
    15. Code Deployment
  14. Practical RMI
    1. RMI Marshaling
    2. Passing Objects
    3. The Factory Pattern
    4. Serialization vs. Remote Reference
    5. Designing for Latency
    6. The Transfer Object Pattern
    7. Controlling Object Location
    8. Exception Handling
  15. Database and SQL Fundamentals
    1. Relational Databases and SQL
    2. Database, Schema, Tables, Columns and Rows
    3. SQL Versions and Vendor Implementations
    4. DDL -- Creating and Managing Database Objects
    5. DML -- Retrieving and Managing Data
    6. Sequences
    7. Stored Procedures
    8. Using SQL Terminals
  16. JDBC Fundamentals
    1. What is the JDBC API?
    2. JDBC Drivers
    3. Making a Connection
    4. Creating and Executing a Statement
    5. Retrieving Values from a ResultSet
    6. SQL and Java Datatypes
    7. Creating and Updating Tables
    8. Handling SQL Exceptions and Proper Cleanup
    9. Handling SQLWarning
  17. Advanced JDBC
    1. SQL Escape Syntax
    2. Using Prepared Statements
    3. Using Callable Statements
    4. Scrollable Result Sets
    5. Updatable Result Sets
    6. Transactions
    7. Commits, Rollbacks, and Savepoints
    8. Batch Processing
  18. Introduction to Row Sets
    1. Row Sets in GUI and J2EE programming
    2. Advantages of RowSets
    3. RowSet Specializations
    4. Using CachedRowSets

Java Technologies