Öppna kurser

Java Best Practices and Design Patterns

Attend this Java Best Practises 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 practises, 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.

Kursmål

  • Employ best practises 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

Förkunskaper

  • Knowledge at the level of:
    • Course 471, Java Programming Introduction
  • 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

Kursinnehåll

Module 1: Effective Programming in Java

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

Module 2: 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

Module 3: Leveraging Design Patterns

Employing common design patterns

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

Module 4: 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 behaviour with reflection

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

Module 5: 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

  • Synchronising 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

Module 6: Architecting for Separation of Concerns

Allocating responsibilities to components

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

Centralising the creation of objects

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

Kursen levereras genom utbildningspartner: Learning Tree
Learning-Tree-Logo_horizontal.png