Based on the popular Effective Java by Joshua Bloch, this course is about more than 90 things all Java Developers should be aware of and practice.   Learn to write Java like a professional and stop making rookie mistakes that increase maintenance cost, bugs and frustration.  Show up ready to code because this is a VERY hands on class!

EVERY STUDENT WHO ATTENDS THE CLASS WILL RECEIVE A COPY OF Effective Java, by Joshua Bloch.

Audience: This course is appropriate for experience Java developers who want to improve the quality of their code and general knowledge of Java best practices.
Course Duration: 5 Days
Prerequisites:

At least 6 months of Java programming experience or a Java Bootcamp is required.

Course Objectives:
  • Chiefly, learn to program effectively in the Java language
  • Learn object creation best practices
  • Understand when to implement Object methods
  • Practice designing and implementing interfaces that encapsulate type
  • Learn scoping practices and principles like, “hide by convention, reveal by need”
  • Understand Generics and bounded wildcards better
  • Implement enums properly
  • Code Lamdas and Streams with purpose
  • Design better classes and methods
  • Eliminate improper syntax and practices from your code
  • Gain a deeper understanding of Exception best practices
  • Improve your concurrency paradigm
  • Rethink Serialization
Course Outline:
  • • Creating and Destroying Objects
    • Factories
    • Builders
    • Singleton with Enum
    • Obsolete References
    • Finalizers
  • Lessons for Common Methods
    • The equals contract
    • Overriding hashCode
    • Why toString
    • Options to clone
    • Comparables
  • Classes and Interfaces
    • Accessibility Concerns
    • Accessors and Mutators
    • Favor Composition Over Inheritance
    • Interfaces Over Abstract Classes
    • Interfaces as Types
    • Static vs non-Static
    • Code to the Interface, not the Implementation
  • Generics
    • Raw Types
    • Unchecked Warnings
    • Lists vs Arrays
    • Generic Types and Methods
    • Bounded WildCards
    • Typesafe Containers
    • TypeErrasure
  • Enums and Annotations
    • Enums vs constants
    • Instance Fields vs Oridinals
    • Annotations vs Naming Patterns
    • Extensible Enums
    • @Override
    • Marker Interfaces
  • Lambdas and Streams
    • Lambdas over Anonymous Classes
    • Method References vs Lambdas
    • Functional Interfaces
    • Judicious Use of Streams
    • Side-effect free functions
    • Collection vs Stream
    • Parallel Streams
  • Methods
    • Parameter Guidelines
    • Defensive Copies
    • Signatures Matter
    • Overloading
    • Varargs
    • Empty  Collections vs Null
    • Using Optional
    • Doc Comments
  • General Programming
    • Local Variables
    • For vs for-each loops
    • Libraries in 10 minutes a day
    • When float and double are trouble
    • To Box or Not To Box
    • Proper Strings
    • Naming Conventions
  • Exceptions
    • Exceptional Conditions
    • Checked vs Runtime Exceptions
    • Favor Standard Exceptions
    • Documenting Exceptions
    • Strive for Failure Atomoicity
    • Don’t Ignore Exceptions
  • Concurrency
    • Handling Shared Mutable Data
    • Executors, tasks and streams over threads
    • Avoiding wait and notify
    • Lazy Initialization
  • Serialization
    • Serialization Options
    • Defensive readObject methods
    • Consider Proxies