Ö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.

Utbildningsmål

Attend this Java Best Practises and Design Patterns training course and learn to solve real-world software development problems. This course is designed for you to learn about programming in Java code. This course provides a comprehensive overview of programming in Java code, with a focus on design patterns and good practises for software development. Topics include the creation and implementation of design patterns, such as adapter patterns, as well as the principles of computer programming and computer science.

The course aims to teach students how to apply design patterns effectively in their own projects, with an emphasis on single-instance programming languages. By the end of the course, students will have a solid understanding of Java programming and will be equipped with the skills necessary to apply design patterns to real-world software development challenges. This is a valuable opportunity to expand your understanding of computer programming and computer science.

  • Employ Java coding best practises to build reliable and scalable Java applications.
  • Effectively apply test-driven development to enhance program stability.
  • Learn design patterns in java to solve architectural problems.
  • Employ advanced Java APIs for multi-threaded programming.

Förkunskaper

 
  • Knowledge at the level of Introduction to Java Programming Training.
  • Three to six months of good practice and experience in Java programming.
  • Understanding of Java classes, the inheritance model, polymorphism, and encapsulation.
  • Familiarity with using fundamental standard edition Java APIs.
  • Ability to Apply object-oriented analysis and design, including defining classes and creating objects.

Innehå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