Course details for Certified Java Specialist - IT Professional Courses

Course Description:

Certified Java Specialist

No Image

Course Content:

Certified Specialist in Java Programming

Certified Specialist in Java Programming
As a Certified Specialist in Java Programming, you have the skills needed to employ
best practices to rapidly build reliable and scal\able Java applications. You will
effectively apply Test Driven Development to enhance program maintainability, solve
architectural problems with proven design patterns, and write robust threaded
applications and avoid concurrency hazards.


    Effective Programming in Java

    Clarifying the goals of best practices
    Identifying the key characteristics of high-quality software
    Organizing classes, packages and subsystems into layers
    Designing to the principles of SOLID

    Applying Test-Driven Development

Exploiting a testing framework

    Composing and maintaining JUnit tests
    Taking advantage of advanced JUnit features
    Testing in the presence of exceptions

Monitoring software health using logging libraries

    Configuring logging with log4j and SLF4J
    Minimizing the impact of logging on performance

Creating marchers and mock objects

    Writing custom Hamcrest matchers
    Testing with fake objects and mocks

    Leveraging Design Patterns

Employing common design patterns

    Observer
    Iterator
    Template method
    Strategy
    State
    Singleton
    Data Accessor Object
    Data Transfer Object
    Composite
    Service Locator
    Proxy
    Factory

Refactoring legacy code

    Identifying reasons to change software
    Clarifying the mechanics of change
    Writing tests for legacy classes and methods

    Extending Applications with Java Meta Programming

Improving type safety with generics and enum types

    Creating generic classes and methods
    Navigating generic class hierarchies
    Implementing enum types for fixed sets of constants

Adding metadata by writing annotations

    Leveraging the built-in and custom annotations
    Annotating with meta-annotations

Modifying runtime behavior with reflection

    Retrieving class and method data dynamically
    Flagging methods with naming conventions
    Adding information to code with annotations
    Assessing disadvantages of reflection

    Tuning for Maximum Performance

Measuring and improving performance

    Assessing response time
    Conducting load and stress tests
    Specifying strategies for improving performance

Exploiting garbage collectors

    Exploring garbage collection metrics
    Choosing appropriate algorithms for garbage collection
    Avoiding the hazards of finalizes
    Preventing memory leaks with reference types

Taking full advantage of threads

    Writing reliable thread-safe code
    Avoiding race hazards and deadlocks
    Employing the Executors framework

Bulletproofing a threaded application

    Synchronizing and sharing data between threads
    Managing the performance implications of synchronization

Exploring alternatives to synchronization

    Taking advantage of the volatile modifier
    Eliminating data sharing with Thread Local variables

    Architectonic for Separation of Concerns

Allocating responsibilities to components

    Translating method calls with the adapter pattern
    Adding behavior with a proxy

Centralizing the creation of objects

    Employing factories to achieve loose coupling
    Implementing Inversion of Control (IoC)