Java Best Practices and Design Patterns Training in Austin

Enroll in or hire us to teach our Java Best Practices and Design Patterns class in Austin, Texas by calling us @303.377.6176. Like all HSG classes, Java Best Practices and Design Patterns may be offered either onsite or via instructor led virtual training. Consider looking at our public training schedule to see if it is scheduled: Public Training Classes
Provided there are enough attendees, Java Best Practices and Design Patterns may be taught at one of our local training facilities.

Answers to Popular Questions:

Yes, this class can be tailored to meet your specific training needs.
Yes, we provide Java Programming consulting services.
Yes, group discounts are provided.

Course Description

Java programmers with experience with databases and with object-oriented programming techniques, will learn to create more complex and advanced programs using Java SE 7.
Course Length: 4 Days
Course Tuition: $2090 (US)


Students should be skilled and experienced in using Java. They should have knowledge of database structures and terminology. Also, they should be familiar with object-oriented programming

Course Outline

Upon successful completion of this course, students will be able to:
Create and manage custom classes.
Control program flow by writing code to respond to specific criteria.
Implement object-oriented programming techniques to create reusable and reliable programs.
Work with Java utility class libraries.
Use the capabilities of the Java I/O package to read and write data to external files or media.
Use collection APIs in Java to manage data.
Use generics to enforce compile-time type checking.
Use multi-threaded programs to help handle multiple tasks concurrently.
Manage Java applications for memory efficiency and create distributable versions of a Java application.
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 matchers 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
• ServiceLocator
• 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 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
Architecting for Separation of Concerns
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)

Course Directory [training on all levels]

Upcoming Classes
Gain insight and ideas from students with different perspectives and experiences.

Java Programming Uses & Stats

Java Programming is Used For:
Android & IOS Development Software Products Video Games Desktop GUI's
Year Created

Most Commonly Used: 
According to Oracle, three billion devices run on Java.  And, because of its real-world applications, it consistently ranks at the top of the TIOBE Programming Community Index. 

Great Career Choice: 
Some of the fastest-growing salaries in the U.S. in 2018 are for Java developers.  (Glassdoor)  

Android Apps Development:
Developers predominatly use their Java skills in building apps for Google's Android. The Android platform is the number one mobile paltform in the world

It Can Run On Any Platform:
Java can compile on Windows and run the same compiled file on Linux, Windows and Mac.

Great Supporting IDE's:
Over the years, coding in Java has become simpler with the introduction of open source development tools, i.e. Eclipse and NetBeans that use Java capabilities for debugging.  


Uses a Lot of Memory:
Performance can be significantly slower with Java and more memory-consuming than natively compiled languages such as C or C++.

Difficulty in Learning: 
Learning Java can be a bit challenging if you are a beginner.  However, once you get the hang of Object Oriented Programming and a decent grasp of the syntax, you will be well on your way.

Slow Start Up Times:
There is quite a bit of one-time initialization done by JDK classes before compiling as well as loading classes and verification (making sure code doesn't do evil things, all of which takes longer that some other languages such as C. 

Verbose and Complex Code:
Long, over-complicated sentences make code less readable and scannable. Compare to let's say Python, we can see how clear Python code appears: It doesn’t require semicolons; uses “and,” “or,” and “not” as operators instead of Java’s “&&,” “||,” and “!”; and generally has fewer bells and whistles such as parentheses or curly braces.

Commercial License Cost:
Companies have to prepare for the changes that Oracle will institute in 2019 . Today, the current version of Java is free and available for redistribution for general purpose computing. However, If you are a DEVELOPER, Oracle recommends you review the roadmap information for Java SE 8 and beyond and take appropriate action depending on the type of application you develop and your distribution mode.

Java Programming Job Market
Average Salary
Job Count
Top Job Locations

New York City 
San Jose
Washington D.C, 

Complimentary Skills to have along with Java Programming

- If you are an experienced Java developer, learning a complimentary language to Java should come much more naturally.  As an example JetBrains recently created the Kotlin programming language which is officially supported by Google for mobile development.  Kotlin compiles to Java bytecode and runs on the JVM; it's purported to address many of Java's shortcomings...

Interesting Reads Take a class with us and receive a book of your choosing for 50% off MSRP.