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 applicationsEffectively apply test-driven development to enhance program maintainabilitySolve architectural problems with proven design patternsEmploy 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)
