Basics of Software Architecture & Design Patterns in Java
4.3 (1,604 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
10,082 students enrolled

Basics of Software Architecture & Design Patterns in Java

A guide to create smart, reusable softwares with SOLID principles and design patterns
Bestseller
4.3 (1,604 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
10,087 students enrolled
Created by Holczer Balazs
Last updated 4/2019
English
English [Auto], French [Auto], 6 more
  • German [Auto]
  • Indonesian [Auto]
  • Italian [Auto]
  • Polish [Auto]
  • Romanian [Auto]
  • Thai [Auto]
Current price: $23.99 Original price: $34.99 Discount: 31% off
23 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 4.5 hours on-demand video
  • 7 articles
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • SOLID principles
  • Design patterns
  • Object oriented design
Requirements
  • Basic Java
  • Object oriented programming
Description

This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns. We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it.

Section 1:

  • what are SOLID principles

  • single responsibility principle

  • open closed principle

  • Liskov's substitution principle

  • interface segregation principle

  • dependency inversion principle

Section 2:

  • what are behavioral design patterns

  • strategy pattern

  • observer pattern

  • command pattern

  • iterator pattern

  • template pattern and null object pattern

  • visitor pattern

Section 3:

  • what are creational design pattern

  • singleton pattern

  • factory pattern

  • builder pattern

Section 4:

  • what is structural design pattern

  • decorator pattern

  • facade pattern

  • adapter pattern

Section 5:

  • the model-view-controller (MVC) model

  • application in Java with MVC

In the first part of the course we are going to learn about the SOLID principles. We are going to talk about the theory as well as the implementations.

The second part of the course is about design patterns. We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know.

Thank for joining the course, let's get started!

Who this course is for:
  • This course is meant for newbies who are familiar with Java and want to be able to write reusable code
Course content
Expand all 58 lectures 04:30:43
+ SOLID Principles ( Design Principles )
20 lectures 01:27:10
------------------------ S -----------------------------
00:01
Single responsibility principle example II
06:07
The open closed principle example I
08:28
The open closed principle II
04:51
------------------------ L -----------------------------
00:01
Liskov substitution principle
03:53
Liskov substitution principle I
07:28
Liskov substitution principle II
03:16
------------------------ I -----------------------------
00:01
Interface segregation principle
02:57
Interface segregation principle example
07:47
------------------------ D -----------------------------
00:01
Dependency inversion principle introduction I
07:18
Inversion of control - dependency injection
05:59
Dependency inversion principle example I
06:02
Dependency inversion principle example II
05:46
+ Behavioral Design Patterns
14 lectures 01:18:52
Strategy pattern introduction
05:16
Strategy pattern example
06:05
Observer pattern introduction
03:01
Observer pattern example
10:06
Command pattern introduction
02:44
Command pattern example I
07:30
Command pattern example II - queuing model
08:10
Iterator pattern example
05:27
Template pattern introduction
01:48
Template pattern example
05:58
Null object pattern introduction
02:06
Null object pattern example
08:35
Visitor pattern introduction
02:33
Visitor pattern implementation
09:33
+ Creational Design Patterns
8 lectures 42:44
Singleton pattern
06:33
Singleton pattern II
02:47
Factory pattern introduction
02:29
Factory pattern example
05:17
Builder pattern introduction
03:31
Builder pattern example - avoiding telescopic constructors
09:08
Why to use builder pattern?
06:39
Data Access Object (DTO) pattern example
06:20
+ Structural Design Patterns
6 lectures 22:20
Decorator pattern introduction
02:17
Decorator pattern example
08:10
Facade pattern introduction
01:08
Facade pattern example
04:56
Adapter pattern introduction
01:07
Adapter pattern example
04:42
+ Model-View-Controller (MVC) Application
4 lectures 14:56
Model-view-controller introduction
03:07
Model-view-controller - Model
01:38
Model-view-controller - View
05:24
Model-view-controller - Controller
04:47
+ Miscellaneous
3 lectures 21:51
Service locator introduction
06:20
Service locator pattern implementation
12:40
JNDI and service locator pattern
02:51