Software View Certified Java Programmer Training - (Java SE 6)

Dates: Request participation. Not scheduled presently. We schedule training programs if you request only.



Frequently asked questions: Click here to view the FAQ page

Employers: Click here for benefits

Time: 9.00 am to 6.00 pm

Training fee: Rs. 15000/= (All inclusive and absolutely low.)

Advance booking fee: Rs. 5000/=

Certification exam fee: Free of charge (first attempt only)

Refreshments and lunch: Not included

Description:

Java is a high level computer programming language and a platform to run computer applications. It has evolved into different directions. You find Java in most of the mobile phones (with Java Micro Edition). Java can be used to write and run simple to complex enterprise applications which may be web based or distributed (with Java Enterprise Edition). You can also write standalone applications (with Java Standard Edition).

This hands-on training program grows industry grade Java programming skills within yourself. It is confined to Java Standard Edition which is the base for both Java Micro Edition and Java Enterprise Edition). See the FAQ page for details.

This training program covers much more than what you need to know to sit for the Sun Certified Java Programmer (SCJP) SE 6 certification exam. SCJP certification is conducted by Oracle Corporation, USA (previously by Sun Microsystems Inc.). SCJP is a worldwide recognized certification program.

Java Duke - The Java Mascot

At the end of this training program, Software View conducts a similar certification exam for no additional charges and those who pass successfully will be entitled with "Software View Certified Java Programmer" status. We encourage you to sit for the SCJP certification as well. See the FAQ page for details.

Training Objectives:

At the end of the training, participants will be able to

  1. Develop Java programs using Java Standard Edition.
  2. Demonstrate proficiency in using Java Standard Editon.
  3. Follow conding standards.
  4. Demonstrate application debugging skills.
  5. Demonstrate object oriented programming skills.
  6. Demonstrate introductory level object oriented design skills with best practices.
  7. Use Java SE API documentation effectively. Generate API documentation for the code written.
  8. Develope GUI applications with Swing library.
  9. Develope database driven applications with JDBC.
  10. Determine the suitable garbage collector for a given application.
  11. Analyze garbage collector and memory management behavior of Java Virtual Machine (JVM) to improve the performance of a given application
  12. Use Eclipse IDE including code generation, refactoring and debugging features.
  13. Sit for the Software View Certified Java Programmer certification exam.
  14. Sit for the Sun Certified Java Programmer (SCJP) certification exam.

Target Groups:

  1. Graduates, undergraduates and interns who want to gain industry grade Java programming skills (and optionally seek certification).
  2. Java developers who want to sit for the SCJP certification exam.
  3. Other software developers who want to learn Java (and optionally seek certification)
  4. Those who are new to computer programming that seek professional education (and optionally certification)
  5. School children (Even those who are doing O/L)

Prerequisites:

  1. No prior computer programming skills are required.
  2. Be familiar with using the computer keyboard. At least know the location of specific keys in the keyboards.
  3. You should be able to follow this training program even if you are an O/L student. Contact us in special cases.

Communication Language:

English (also with Sinhala explanations if requested)

Duration:

8 days (~64 hours)

Facilitator:

Kamal Wickramanayake (Profile)

Notes:

  1. This is a hands-on training program and not limited to theoretical discussions. Each participant will be given a separate computer to work with.
  2. The topics of the training program will not be delivered in the same order as listed below. For example, we will cover Eclipse and application debugging sections somewhere in the middle.
  3. This specially priced training program is conducted for the said price only for the individual training requesters. Corporate training requests are priced differently (and is higher).

Training Content:

  1. Introduction To Java Platform
    • History of Java
    • The Java platform
    • Java evolution into various areas
    • Java Community Process (JCP)
    • Future of Java
  2. Getting Started With Java Programming
    • Installing Java Development Kit (JDK)
    • Setting PATH environment variable
    • Writing the first Java program
    • Compiling
    • Running
    • Decompiling your first Java program
    • CLASSPATH environment variable
    • Difference between JDK and JRE (Java Runtime Environment)
  3. Introduction To Computer Programming
    • A computer as a data processing machine
    • What is involved in computer programming?
    • Developing simple algorithms
    • Overview of software development life cycle
  4. Coding Standards
    • Why coding standards are important?
    • Generally accepted standards
  5. Variables
    • What is a variable?
    • Data types
    • Primitive and reference data types
    • Variable declaration, initialization, usage
    • Valid and invalid variable names
    • Arrays
    • Strings
    • Type casting
  6. Operators
    • Assignment operators
    • Arithmetic operators
    • Relational operators
    • instanceof operator
    • Logical operators
    • Conditional operator
    • Operator precedence
  7. Branching
    • if, switch statements
    • Loops (for, the enhanced for loop [for-each], do, while, labels, break, and continue)
    • Methods
    • Exceptions (Covered as a separate topic - see below)
    • Assertions (Covered as a separate topic - see below)
  8. Object Oriented Programming (OOP)
    • History of programming language paradigms
    • Structure of an object oriented application
    • State and behavior of objects
    • Classes and objects
    • Interface of an object
    • Translating real world concepts to computer domain
    • OOP fundamentals
    • Implementing encapsulation
    • Implementing abstraction
    • Implementing inheritance
    • Implementing polymorphism
    • Tight encapsulation, loose coupling, and high cohesion in classes
    • Working with different forms of relationships between objects
  9. More On Classes
    • Types of classes (concreate, abstract, nested)
    • Interfaces
    • Constructors
    • Default constructor
    • Static, instance, local variables
    • Access specifiers
    • Method overriding and overloading
    • Import statements, package
    • Scoping
    • Casting
    • Pass by value and pass by reference
  10. Constants And Enumerations
    • Using static finals
    • Enums
  11. Java API Documentation
    • Getting familiar with Java Standard Edition API documentation
    • Documentating the source code you write
    • Using the javadoc command to generate API documentation
  12. Primitive Wrappers
    • Purpose of primitive wrappers
    • Autoboxing and unboxing
  13. Error Handling With Exceptions
    • Overview (What & Why)
    • Catching/handling exceptions (try-catch-finally blocks)
    • Throwing exceptions
    • Defining new exception types and using them
    • Runtime exceptions, checked exceptions, errors
    • Commonly encountered exceptions
    • Impact of throwing exceptions on application performance
  14. Assertions
    • What are assertions?
    • How to use assertions?
    • Proper and inappropriate use of assertions
  15. Garbage Collection/Memory Management
    • Overview of garbage collection
    • Different garbage collection algorithms and their behavior
    • Generational garbage collectors
    • finalize() method of java.lang.Object class
    • Forcing finalization with System.gc()
  16. Fine Tuning JVM
    • Analyzing garbage collector and memory management behavior of JVM
    • Detecting memory leaks
    • Detecting performance bottlenecks
    • Determining optimal memory requirements of an application and controlling heap size
    • Determining and using a suitable garbage collector
    • Application launcher standard/non-standard options (JVM parameters)
  17. Working With Strings
    • String class
    • StringBuilder class
    • StringBuffer classes
    • String comparison
    • JVM special treatment on Strings
    • Formatting (Covered in a separate section - see below)
    • Regular expressions (Covered in a separate section - see below)
  18. I/O Manipulation
    • Overview of I/O streams (Readers/Writers/Input Streams/Output Streams)
    • Working with File class
    • Using file streams
    • Buffered streams
    • Wrapping streams
    • Using PrintWriter class
    • Using the Console class
    • Using piped streams
  19. Locale Class, Text Formatting & Pattern Matching
    • The java.util.Locale class
    • Formatting and parsing dates, numbers, and currency values
    • Working with regular expressions (Pattern, Matcher classes)
    • Formatter, Scanner, PrintWriter.format/printf
  20. Collections & Generics
    • Collection classes and interfaces
    • hashCode and equals methods
    • NavigableSet and NavigableMap
    • Generic and non-generic versions of Collections API
    • Writing code that uses features of generics
    • Using utility classes in java.util package
    • Comparable interface
    • Comparator interface
    • Natural order
    • Sorting
  21. Concurrency
    • Overview (Application/Process/Thread/Multi-Threading/Multi-Processing/Multi-Processor)
    • Thread class
    • Runnable interface
    • Thread priority (Pre-Emptive and Time Slicing, Thread.yeild(), Thread.sleep())
    • Different thread synchronization mechanisms (Synchronization blocks, Poling, wait and notify)
    • Thread grouping
    • Inter-thread communication (Shared data, Pipes)
  22. Networking With Java
    • Overview of networking with Java
    • Using the Socket class
    • Using the ServerSocket class
    • Multi-threading considerations
  23. Object Oriented Design Skills (Introductory Level)
    • Identification of objects and classes
    • Class responsibility assignment
    • Identification of associations
    • Using UML class diagrams and sequence diagrams
    • Using the layers pattern
  24. GUI Programming With Swing (Intermediate Level)
    • Using basic widgets
    • Working with JTable and TableModel
    • Delegation event model
    • Working with layout managers
    • Writing an applet
    • Threading concerns and solutions
  25. Java Database Connectivity (JDBC) (Introductory Level)
    • Working with MySQL RDBMS
    • Designing a database schema for an application
    • Using Structured Query Language (SQL)
    • Using JDBC to interact with the database
  26. Working with JAR files
    • Purpose of JAR files
    • Organization of content inside a JAR file
    • Creating, using JAR files
  27. Eclipse Integrated Development Environment (IDE)
    • Background of Eclipse Platform
    • Eclipse capabilities beyond an IDE
    • Concepts (Workbench, workspace, perspectives, editors, views)
    • Organization of a Java project
    • Compiling a project
    • Running a project
    • Refactoring features
    • Debugging features
    • Importing/exporting
  28. Application Debugging Skills
    • Difference between testing and debugging
    • Different debugging strategies
    • Using the debugger of an IDE
    • Understanding exception messages
    • Understanding compiler messages
    • Problem isolation
    • Improving debugging skills
    • Where to get help from?