Java Design Patterns and Architecture

Discover how to use design patterns to structure and simplify your Java program on this FREE Java Tutorial for Beginners
203 reviews
TAUGHT BY
  • John Purcell Software Development Trainer

    After working as a software developer and contractor for over 14 years for a whole bunch of companies including CSC, Proquest, SPSS and AT&T in the UK and Netherlands, I decided to work full-time as a private software trainer. I now live in the beautiful city of Budapest, Hungary, from where I run the website Cave of Programming.

WHAT'S INSIDE
  • Lifetime access to 19 lectures
  • 4+ hours of high quality content
  • A community of 47900+ students learning together!
  • 140+ discussions
SHARE

Java Design Patterns and Architecture

Discover how to use design patterns to structure and simplify your Java program on this FREE Java Tutorial for Beginners
203 reviews

HOW UDEMY WORKS?

Discover courses made by experts from around the world.

Take your courses with you and learn anytime, anywhere.

Learn and practice real-world skills and achieve your goals.

COURSE DESCRIPTION

Discover some of the most useful, important and common design patterns in Java; reusable code patterns that you can use to structure your program and perform common tasks. Includes lots of examples with full source code. "Design Patterns" has been the big buzz phrase in the Java community for some time now, and if you want to be able to write effective Java programs, work as a Java developer or pass exams in Java, you can't afford to miss out. Fortunately, this course is entirely free :)

Take this FREE Java Design Patterns and Java Architecture course right now and learn everything about java design patterns and java architecture.

    • Basic Java knowledge
    • Over 19 lectures and 4.5 hours of content!
    • Understand common design patterns in Java
    • Know when to apply common patterns
    • Be able to use design patterns to help structure your software
    • Software developers
    • Java students with an intermediate-level knowledge
    • Java beginners who like being dropped in at the deep end

THE UDEMY GUARANTEE

30 day money back guarantee
Lifetime access
Available on Desktop, iOs and Android
Certificate of completion

CURRICULUM

  • SECTION 1:
    Methodology
  • 1
    Introduction
    04:18
    An introduction to the course.
  • 2
    A Brief History of Software Design
    17:36
    This is just some notes about software design; partly because I want to explain why I don't know much about formal design methodologies and so won't cover them in this course (even though we will talk a fair bit about software design), partly just to explain what little I do know about it, and partly because I need to get a few things off my chest ....
  • 3
    Front End / Back End
    07:11
    We'd better start by looking at the most fundamental of design patterns -- so fundamental that it can be overlooked, but it's the pattern that every software developer has in his or her head, and works from as a starting point.
  • SECTION 2:
    Structural Patterns
  • 4
    Model-View-Controller: The Theory
    09:25
    In this tutorial we'll look at the theory behind MVC, before going on to implement an example
  • 5
    Model-View-Controller: In Practice
    18:36
    In this tutorial we'll set up a basic MVC framework, leaving out the "listener" stuff, which we'll come back to later on.
  • 6
    Observer Pattern: The Theory
    14:04

    We need the observer pattern in order to complete our model view controller pattern. Even if you don't use MVC, the observer pattern is vital to user interface programming. It's one of the vital structural patterns that hold modern software together. It can also be quite tricky to understand initially, so for that reason we'll go through the theory of it before actually tackling it.

  • 7
    Observer Pattern: An Example Involving Buttons
    19:22
    Let's take a look at one of the easiest (inasmuch as this pattern can be called "easy") usages of the observer pattern; adding handlers to buttons in Swing. Don't worry if you don't know Swing; this code would look pretty much the same for a variety of situations involving timers and other uses of Observer.
  • 8
    Observer Pattern: Implementing From Scratch (with MVC)
    25:41
    Let's take a look at an example implementation of the observer pattern. In this tutorial I'll make my "controller" listen to my "view" in my MVC implementation, but you could make any object listen to any other object. You just need some kind of a situation where the object being listened to can somehow signal that something has happened for some reason -- for example, a button can be clicked or a timer can trigger. Your other object can then "listen" to the first object.
  • 9
    An MVC Controversy
    05:30
    I realised while making this course that it's a controversial issue, whether the model should talk to the view directly or not. Well, controversial among those who like controversy. Most software developers would say that you should decide this based on what you need to implement. The model should never use View classes; everyone agrees on that. Aside from basic stuff like that, things like this are just implementation details and not worth getting too hung up on.
  • SECTION 3:
    Smaller Scale Patterns
  • 10
    The Singleton Pattern
    14:04
    The singleton pattern is controversial, but important to know since you'll encounter it even if you decide not to use it.
  • 11
    Beans
    04:28
    We'll need a "bean" to use as the "transfer object" in the DAO patterns. They're also useful for lots of other things, such as event objects and storing data in your program.
  • 12
    DAO
    14:58
    We'll start looking at the DAO pattern in this tutorial (there's a bit more to come!). DAO is a pattern for abstracting away databases and keeping all your SQL or LDAP code or whatever safely in particular files.
  • 13
    DAO Factories
    06:34
    The DAO pattern is potentially multi-layered. Here we'll add one more layer, by creating a "factory" that can create our DAO objects.
  • 14
    JUnit Basics: Testing the DAO
    23:18
    An introduction to JUnit. This seems like a good place to put a JUnit tutorial, because we really need to test the DAO class before proceeding further.
  • 15
    Extending DAO for Multiple Databases
    23:37
    Let's extend the DAO pattern so that it can cope with multiple databases. We'll need to define interfaces that the existing stuff implements, and maybe even an abstract class for a final touch.
  • 16
    Saving to Memory
    15:21
    Often applications don't save every modification you make directly to disk or to a database, but work with data in memory. In this tutorial we'll look at an example of that, and finally make use of our "model" class.
  • 17
    Factory Pattern
    18:31
    The factory pattern is one of the most important patterns, and one that you're likely to get asked about on job interviews and exams. It involves creating a method that instantiates and returns objects, rather than the user of the objects instantiating them directly with "new". This allows you to pre-configure objects or to engage in lengthy determinations of precisely which object to return, which can then be hidden from the end user of your API.
  • 18
    Facades
    06:51
    The Facade pattern is almost too simple to be called a pattern. Nevertheless, being familiar with it will prevent you from panic when your colleague or boss casually starts wittering about "creating some facades". When you see what it actually is, your mental state will change from panic to relief, combined with frustration that people can't just speak normally.
  • 19
    Adapter Pattern
    18:14
    The Adapter pattern simply consists of a class that "adapts" from the interface implemented by some class (which contains the functionality you need) to a different interface.

UDEMY BY THE NUMBERS

5,200,000
Hours of video content
19,000,000
Course Enrollments
5,800,000
Students

RATING

  • 135
  • 49
  • 8
  • 2
  • 9
AVERAGE RATING
NUMBER OF RATINGS
203

REVIEWS

  • Wuchen Wang
    Good course

    Very instructive, informative.

  • Vivek Lakhanpal
    Good course for a beginner

    Great free resource for a beginner to have a sneak peak at how Patterns works in Java. The way John has explained the stuff is pretty neat and simple.

  • Mouhamadou Bop
    Enjoyed it!!!

    This is an excellent course for both new and experienced Java on Design Patterns. It was really beneficial to learn some new concepts and reviewed some other pattern that I have not had the chance to use in a while.

  • Carlos Hilner Ferreira Costa
    bom curso

    bom professor

  • Kiril Anastasov
    Go for it.

    Great tutorial to help you started or revisit the design patterns.