Java Best Practices and Design Patterns Training

Course 516

  • Duration: 4 days
  • Labs: Yes
  • Language: English
  • Level: Intermediate
Get This Course $3,285
  • 4-day instructor-led training course
  • After-course instructor coaching benefit
  • Learning Tree end-of-course exam included
#516
  • Guaranteed to Run - you can rest assured that the class will not be cancelled.
    Aug 16 - 19 9:00 AM - 4:30 PM EDT
    Ottawa or AnyWare
  • Nov 7 - 10 9:00 AM - 4:30 PM EST
    Herndon, VA or AnyWare
  • Feb 14 - 17 9:00 AM - 4:30 PM EST
    Ottawa or AnyWare
  • May 9 - 12 9:00 AM - 4:30 PM EDT
    Herndon, VA or AnyWare

Attend this Java Best Practices and Design Patterns training course and learn to solve real-world software development problems, and deliver responsive applications that are fast and reliable. Learn how to leverage Java best practices, avoid pitfalls and perform industry-standard software development techniques. Learn design patterns in Java to implement proven solutions to reoccurring problems, and apply idioms and patterns to improve your Java code.

  • Knowledge at the level of:
  • Three to six months of Java programming experience
  • You should be able to:
    • Understand Java classes, the inheritance model, polymorphism, and encapsulation
    • Use fundamental standard edition Java APIs
    • Apply object-oriented analysis and design, including defining classes and creating objects

Java Best Practices and Design Patterns Training Delivery Methods

  • After-course instructor coaching benefit
  • Learning Tree end-of-course exam included
  • After-course computing sandbox included

Java Best Practices and Design Patterns Training Course Benefits

  • Employ best practices to build reliable and scalable Java applications
  • Effectively apply test-driven development to enhance program maintainability
  • Solve architectural problems with proven design patterns
  • Employ advanced Java APIs for multi-threaded programming

Java Design Patterns Course Outline

  • 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

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 matchers and mock objects

  • Writing custom Hamcrest matchers
  • Testing with fake objects and mocks

Employing common design patterns

  • Observer
  • Iterator
  • Template method
  • Strategy
  • State
  • Singleton
  • Data Accessor Object
  • Data Transfer Object
  • Composite
  • ServiceLocator
  • Proxy
  • Factory

Refactoring legacy code

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

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

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 finalizers
  • 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 ThreadLocal variables

Allocating responsibilities to components

  • Translating method calls with the adaptor pattern
  • Adding behavior with a proxy

Centralizing the creation of objects

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

Need Help Finding The Right Training Solution?

Our training advisors are here for you.

Course FAQs

Yes! We know your busy work schedule may prevent you from getting to one of our classrooms which is why we offer convenient online training to meet your needs wherever you want, including online training.

Chat With Us