Byte Size Chunks : Java Model-View-Controller (MVC)
4.4 (6 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
814 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Byte Size Chunks : Java Model-View-Controller (MVC) to your Wishlist.

Add to Wishlist

Byte Size Chunks : Java Model-View-Controller (MVC)

A little treat with all you need to know about the MVC paradigm in Java
4.4 (6 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
814 students enrolled
Created by Loony Corn
Last updated 3/2016
English
Current price: $10 Original price: $20 Discount: 50% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 2.5 hours on-demand video
  • 13 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Understand the Model-View-Controller paradigm, the Observer and Command Design patterns that are at the heart of modern UI programming
  • Understand exactly how the Model-View-Controller paradigm is used in Java, both in Swing and in JavaFX
  • Implement event and menu handling using the Observer and Command design patterns
  • Identify how the MVC paradigm manifests itself in different UI programming use-cases
  • Gain a superficial understanding of JavaFX and Properties and Bindings
View Curriculum
Requirements
  • Basic knowledge of Java
Description
  • Prerequisites: Basic understanding of Java
  • Taught by a Stanford-educated, ex-Googler, husband-wife team
  • Please don't take this class if you have already signed up for our From 0 to 1: Design Patterns course (that includes a far longer and more in-depth version of this material)

This is a quick and handy course with exactly what you need to know (nothing more, nothing less!) about the MVC paradigm in Java.

Let’s parse that.

  • The course is quick and handy: It explains the Model-View-Controller paradigm, the Command and Observer design patterns in just the right level of detail for you to put these to work today.
  • The course has exactly what you need - nothing more, nothing less. It starts from zero, builds up the design, then gives plenty of real-world examples, but crisply and quickly.
  • The course is also quirky. The examples are irreverent. Lots of little touches: repetition, zooming out so we remember the big picture, active learning with plenty of quizzes. There’s also a peppy soundtrack, and art - all shown by studies to improve cognition and recall.

What's Covered:

  • The MVC Paradigm
  • Observer Design Pattern and event handling
  • Command Design Pattern and action objects


Using discussion forums

Please use the discussion forums on this course to engage with other students and to help each other out. Unfortunately, much as we would like to, it is not possible for us at Loonycorn to respond to individual questions from students:-(

We're super small and self-funded with only 2-3 people developing technical video content. Our mission is to make high-quality courses available at super low prices.

The only way to keep our prices this low is to *NOT offer additional technical support over email or in-person*. The truth is, direct support is hugely expensive and just does not scale.

We understand that this is not ideal and that a lot of students might benefit from this additional support. Hiring resources for additional support would make our offering much more expensive, thus defeating our original purpose.

It is a hard trade-off.

Thank you for your patience and understanding!


Who is the target audience?
  • Yep! Programmers who know some Java, but are new to User-Interface programming
  • Yep! Programmers who are a bit short on time and would like a quick refresher of the design priniciples underlying modern UI programming in Java
  • Nope! Folks that are entirely new to programming (we'd suggest our From 0 to 1: Java class for you instead)
  • Nope! Folks that are looking to learn Design Patterns in depth (we'd recommend our From 0 to 1: Design Patterns course for you instead)
  • Nope! Folks that are looking to learn Swing or JavaFX in detail (we'd recommend our From 0 to 1: JavaFX and Swing course for you instead)
Students Who Viewed This Course Also Viewed
Curriculum For This Course
15 Lectures
02:40:40
+
Introduction
1 Lecture 02:15

We'll start with an introduction - what this course covers and what you should be able to do at the end of the course.

Preview 02:15
+
The MVC Paradigm
3 Lectures 30:52

he Model-View-Controller (MVC) paradigm is ubiquitous in UI programming; along with the Observer and Command patterns, MVC has practically defined modern User-Interface programming.

Preview 13:59

Models contain data, views define the UI, and controllers respond to user input and update the model and the view. We see how this plays out in a Media Player application.
The Model View Controller Design Pattern In Action: A MediaPlayer Example
08:11

Models contain data, views define the UI, and controllers respond to user input and update the model and the view. We see how this plays out in a Charting application.

The Model View Controller Design Pattern In Action: A Chart Example
08:42

MVC
3 questions
+
The Observer Pattern
6 Lectures 01:06:40

The Observer Pattern, along with the MVC and Command Patterns, has practically defined modern UI programming. Publishers publish updates when their state changes, and Subscribers can listen in on these updates. An event is fired when the state changes, and the listener responds via a Command object called the event listener code.

The Observer Design Pattern: Introduction
09:34

Java has recently added substantial language support for the Observer Pattern via two new types of objects - Properties and Bindings. Let's understand when these types of variables can save us a bunch of work.

The Observer Design Pattern In Action: Properties and Bindings - I
14:42

More on the newly added language constructs for the Observer Pattern, Properties and Bindings. We dig deep into the mechanics and underlying interfaces.

The Observer Design Pattern In Action: Properties and Bindings - II
09:27

After the relatively new-age Properties and Bindings, we turn to classic use-cases of the Observer Pattern, in User Interface elements such as mouse click handlers and tree views. The Observer Pattern is used in clever ways in Swing and other UI frameworks, allowing the user great flexibility in responding to a variety of different user actions.
The Observer Design Pattern In Action: Mouse Handling and Tree
07:06

We dig deep into the interplay between the Model-View-Controller and the Observer Pattern, tied together via the Command Pattern. These three patterns have, together, defined modern User-Interface programming

The Observer Design Pattern In Action: MVC + Observer = UI Magic
10:34

Models contain data, views define the UI, and controllers respond to user input and update the model and the view. We see how the Observer Pattern plays a crucial role in seting up this MVC example for success - for instance, a slider that wires up the volume of the media is just about 1 line to set up correctly.

The Observer Design Pattern In Action: A MediaPlayer Example - I
15:17

The Observer Pattern
6 questions

The Observer Pattern - True/False
5 questions
+
The Command Pattern
5 Lectures 01:00:53

The Command Design Pattern is used to separate an action from its execution. A seemingly abstract idea, and an incredibly powerful one. The Command Pattern, along with the Observer and MVC Patterns, has practically defined modern User Interface Programming.

The Command Design Pattern
11:50

The idea of encapsulating an action in an object can be used to retro-fit functional programming support into an object-oriented language like Java. Lambda functions, in particular, are a functional programming concept that has become a cross-over hit in the object-oriented world of Java.
The Command Design Pattern In Action: Lambda Functions - I
09:51

We continue with functional-programming support in Java. In addition to lambda functions, there are also powerful aggregate operators - map, foreach and filter - that we can use to chain lambda functions together

The Command Design Pattern In Action: Lambda Functions - II
10:04

The Command Design Pattern is used to separate an action from its execution. We see how this idea is used as the starting point of most modern Threading libraries. Java has old-school and new ways of getting Multi-threading done, and both of these start with the Command Pattern

The Command Design Pattern In Action: Threading
14:29

The Command Design Pattern is used to separate an action from its execution. This idea serves as the basis of two really neat applications: implementing Undo, and logging activity. Let's see how.

The Command Design Pattern In Action: Undo and Logging
14:39

The Command Design Pattern
5 questions
About the Instructor
Loony Corn
4.3 Average rating
4,594 Reviews
36,460 Students
75 Courses
An ex-Google, Stanford and Flipkart team

Loonycorn is us, Janani Ravi and Vitthal Srinivasan. Between us, we have studied at Stanford, been admitted to IIM Ahmedabad and have spent years  working in tech, in the Bay Area, New York, Singapore and Bangalore.

Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft

Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too

We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!

We hope you will try our offerings, and think you'll like them :-)