Byte Size Chunks: Java Object-Oriented Programming & Design

About Course

•  

  • 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: Learn Java Programming course (that includes a far longer and more in-depth version of this material
  • The course is quick and handy: It explains object-oriented programming in Java 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.

Curriculam

• Section 1: An Object-Oriented State of Mind
  	Lecture 1	Objects are puppies	03:45
  	Lecture 2	Classes and Objects: An Object-Oriented State of Mind	18:59
  	Lecture 3	Static Variables and Methods	06:47
  	Lecture 4	Access Modifiers	14:52
  	Quiz 1	Java Keyboards	1 question
  	Lecture 5	Classes and Objects: A Simple Example I	11:57
  	Lecture 6	Classes and Objects: A Simple Example II	09:17
  	Lecture 7	Is-A Inheritance - setting up a class hierarchy	08:57
  	Lecture 8	Is-A Inheritance - parent class, child class relationship	07:09
  	Lecture 9	Runtime polymorphism	14:21
  	Lecture 10	The Object Base Class	06:08
  	Lecture 11	Interface: Introduction	14:19
  	Lecture 12	Interfaces vs Abstract Base Class	06:43
  	Quiz 2	Interfaces	1 question
  	Quiz 3	Interfaces and Abstract Base Class	1 question
  	Quiz 4	Inheritance	1 question
  	Lecture 13	Interfaces in Detail	15:36
  	Lecture 14	Interface Default Methods: Avoid Backward Compatibility Nightmares	11:15
  	Lecture 15	Interfaces and Inheritance in Action	18:58
  	Quiz 5	Classes and Objects	1 question
  Section 2: Java Language Constructs: The Best Thing Since Sliced Bread
  	Lecture 16	Exceptions	12:09
  	Lecture 17	The Immutability of Strings	07:27
  	Lecture 18	Object Identity: == and .equals()	10:27
  	Lecture 19	Generics: Type Safety and Code Re-use	16:07
  	Lecture 20	Collections: Containers for all purposes	11:47
  	Lecture 21	Generic Containers - much cooler	09:48
  	Lecture 22	Inner Classes: Horses for Courses - Static vs Non-Static	14:15
  	Lecture 23	Inner Classes: Horses for Courses - Anonymous and Local	09:45
  	Quiz 6	Generic Classes	1 question
  	Quiz 7	Static and non-static nested classes	1 question
  	Quiz 8	Classes and Objects	1 question
  	Quiz 9	Static Nested Class	1 question
  Section 3: A serious drill with lots of code:-)
  	Lecture 24	A File is like a Barrel	11:21
  	Lecture 25	A Serious Java Application: Our First	14:45
  	Lecture 26	A Serious Java Application: Parsing Stock Ticker Data - I	18:42
  	Lecture 27	A Serious Java Application: Parsing Stock Ticker Data - II	10:40
  	Lecture 28	A Serious Java Application: Parsing Stock Ticker Data - III	17:01
  	Lecture 29	A Serious Java Application: Parsing Stock Ticker Data - IV	16:25
  	Lecture 30	A Serious Java Application: Parsing Stock Ticker Data - V	16:09
  	Quiz 10	Files	1 question
  Section 4: Packages and Jars
  	Lecture 31	Jars: Not As Boring as They Might Seem	13:28
  	Lecture 32	Packages	07:04
  	Lecture 33	Packages and Jars in Action	04:23
  Section 5: Some Object-Oriented Design Principles
  	Lecture 34	Design Principle #1: Rely on Interfaces, not Implementations	04:14
  	Lecture 35	Design Principle #2: The Open/Closed Principle	05:31
  	Lecture 36	Design Principle #3: The Principle of Least Knowledge	04:39
  	Lecture 37	Design Principle #4,5: Dependency Inversion and the Hollywood Principle	05:46

What included in this Course?

• • Understand Object-Oriented programming concepts at the level where you can have intelligent design conversations with an experienced software engineer
  • Understand the nuances of Java specific constructs in serialisation, exception-handling, cloning, the immutability of strings, primitive and object reference types
  • Understand class and interface design
  • Define, implement and instantiate objects
  • Create class hierarchies using inheritance
  • Apply and benefit from encapsulation, runtime polymorphism and interface-driven programming

  What's covered:

  • The Object-Oriented Paradigm: Classes, Objects, Interfaces, Inheritance; how an OO mindset differs from a functional or imperative programming mindset;
  • Mechanics: the mechanics of OO - access modifiers, dynamic dispatch, abstract base classes v interfaces.
  • Principles: The underlying principles of OO: encapsulation, abstraction, polymorphism
  • Interfaces, abstract base classes and interface default methods
  • Packages and Jars: The plumbing is important to understand too.
  • Language Features: Serialisation; why the Cloneable interface sucks; exception handling; the immutability of Strings;
  • Types: the Object base class; the instanceof operator, primitive and object reference types; pass-by-value and pass-by-object-reference.

Who should buy this course?

• • Folks that are new to (or somewhat intimidated by) Object Oriented Programming
  • Experienced C programmers looking to make the leap from procedural/imperative to object-oriented programming
  • No pre-requisites, this class starts from basics