Learn Java Programming : from 0 to 1

About Course

•  

  • This course will use Java and an Integrated Development Environment (IDE). Never fear, we have a detailed video on how to get this downloaded and set up.
  • Hundreds of lines of source code, and hundreds of lines of comments - just download and open in your IDE!
  • This is a Java course for everyone. Whether you are a complete beginner (a liberal arts major, an accountant, doctor, lawyer) or an engineer with some programming experience but looking to learn Java - this course is right for you.
  • The course is accessible because it assumes absolutely no programming knowledge, and quickly builds up using first principles alone
  • Even so, this is a serious Java programming class - the gradient is quite steep, and you will go from absolute beginner to an early intermediate level
  • 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.
   

Topics covered in this course

• Section 1: You, Us & This Course
  	Lecture 1	Introduction	02:26
  Section 2: Coding Is Like Cooking
  	Lecture 2	Coding is like Cooking	16:05
  	Lecture 3	Functions as Food Processors	19:51
  	Lecture 4	Installing Java and Setting up an IDE	17:55
  	Lecture 5	Variables - Primitives, Objects, Null	19:18
  	Lecture 6	Hello World! (Drill)	10:34
  	Lecture 7	Don't Jump Through Hoops, Use Loops	11:53
  	Lecture 8	Arrays and Lists - Drill	19:56
  	Lecture 9	Maps	05:43
  	Lecture 10	Maps - Drill	11:03
  Section 3: An Object-Oriented State of Mind
  	Lecture 11	The Evolutionary Arc from C, through C++, to Java	12:53
  	Lecture 12	Objects are like puppies	05:40
  	Lecture 13	Classes and Objects: An Object-Oriented State of Mind	19:50
  	Lecture 14	Static Variables and Methods	07:55
  	Lecture 15	Access Modifiers	19:59
  	Lecture 16	Classes and Objects: A Simple Example I	13:27
  	Lecture 17	Classes and Objects: A Simple Example II	10:06
  	Lecture 18	Is-A Inheritance - setting up a class hierarchy	11:22
  	Lecture 19	Is-A Inheritance - parent class, child class relationship	07:44
  	Lecture 20	Runtime Polymorphism	15:59
  	Lecture 21	The Object Base Class	07:30
  	Lecture 22	Interfaces : Introduction	15:59
  	Lecture 23	Interfaces vs Abstract Base Class	07:41
  	Lecture 24	Interfaces In Detail	17:21
  	Lecture 25	Interface Default Methods: Avoid Backward Compatibility Nightmares	12:31
  	Lecture 26	Interfaces and Inheritance in Action	20:00
  Section 4: Java Language Constructs: The Best Thing Since Sliced Bread
  	Lecture 27	Exceptions	17:19
  	Lecture 28	Object Identity: == and .equals()	13:40
  	Lecture 29	Generics: Type Safety and Code Re-use	16:00
  	Lecture 30	Collections: Containers for all purposes	12:17
  	Lecture 31	Generic Containers - much cooler	09:09
  	Lecture 32	Ordered Associative Containers - The Tree Map	10:32
  	Lecture 33	Inner Classes: Horses for Courses - Static vs Non-Static	15:13
  	Lecture 34	Inner Classes: Horses for Courses - Anonymous and Local	11:11
  	Lecture 35	A File is like a Barrel	13:47
  	Lecture 36	A Serious Java Application: Our First	17:35
  	Lecture 37	A Serious Java Application: Parsing Stock Ticker Data - I	19:40
  	Lecture 38	A Serious Java Application: Parsing Stock Ticker Data - II	11:56
  	Lecture 39	A Serious Java Application: Parsing Stock Ticker Data - III	19:16
  	Lecture 40	A Serious Java Application: Parsing Stock Ticker Data - IV	16:56
  	Lecture 41	A Serious Java Application: Parsing Stock Ticker Data - V	17:39
  Section 5: Threading and Concurrency: A Lot Going On All At Once
  	Lecture 42	Threading, and Why It Matters	17:26
  	Lecture 43	Threading: Old school vs New school	15:14
  	Lecture 44	Traditional Threading Support	15:22
  	Lecture 45	Threading and Concurrency: A lot going on at once	13:16
  	Lecture 46	Synchronized Methods, Livelock, Deadlock and Starvation	12:22
  	Lecture 47	Working with threads - and our first synchronization bug!	17:01
  	Lecture 48	Threads: Object locking and static variables in action	07:12
  	Lecture 49	Digging Deeper into Callables and Futures	17:17
  	Lecture 50	Threading: New school fun in action	14:29
  	Lecture 51	Threading: Executors are pretty cool	06:22
  Section 6: Functional Programming: Crossover Hits
  	Lecture 52	Functional Programming: A State of Mind	03:56
  	Lecture 53	Lambda Functions: A Crossover Hit	13:15
  	Lecture 54	Lambda Functions: No more boiler-plate code	12:22
  	Lecture 55	Lambda functions for real - in code	19:10
  Section 7: Recursion, Reflection, Annotations, Dates, Packages and Jars
  	Lecture 56	Recursion	17:50
  	Lecture 57	Reflection: Not a Dark Art	16:19
  	Lecture 58	Reflection: A real use case	10:35
  	Lecture 59	Annotations: Notes to Self can be Super-Useful	17:07
  	Lecture 60	Working With Dates in Java	18:29
  	Lecture 61	Jars: Not As Boring as They Might Seem	14:51
  	Lecture 62	Packages	07:24
  	Lecture 63	Packages and Jars in Action	04:23
  	Lecture 64	Serialisation	10:12
  	Lecture 65	Cloning	16:04
  	Lecture 66	The Immutability of Strings	07:26
  Section 8: UI Programming: Swing, MVC, and JavaFX
  	Lecture 67	Frameworks - A State of Mind	19:49
  	Lecture 68	The Basic Idea of Swing	19:06
  	Lecture 69	Swing and the Model-View-Controller Paradigm	14:23
  	Lecture 70	The Mechanics of Swing - I	09:58
  	Lecture 71	The Mechanics of Swing - II	18:12
  	Lecture 72	A Serious Swing App: News Curation Browser - I	18:58
  	Lecture 73	A Serious Swing App: News Curation Browser - II	15:54
  	Lecture 74	A Serious Swing App: News Curation Browser - III	18:40
  	Lecture 75	A Serious Swing App: News Curation Browser - IV	19:32

What you will get from this course?

• • Programming Basics: What programming is, and a carefully thought-through tour of the basics of any programming. Installing and setting up an IDE and writing your first program
  • The Object-Oriented Paradigm: Classes, Objects, Interfaces, Inheritance; how an OO mindset differs from a functional or imperative programming mindset; the mechanics of OO - access modifiers, dynamic dispatch, abstract base classes v interfaces. The underlying principles of OO: encapsulation, abstraction, polymorphism
  • Threading and Concurrency: A deep and thorough study of both old and new ways of doing threading in Java: Runnables, Callables, Threads, processes, Futures, Executors.
  • Reflection, Annotations: The how, what and why - also the good and bad
  • Lambda Functions: Functional constructs that have made the crossover into the mainstream of Java - lambda functions, aggregate operators.
  • Modern Java constructs: Interface default methods; also detailed coverage of Futures and Callables, as well as of Lambda functions, aggregation operators and Swing.
  • Packages and Jars: The plumbing is important to understand too.
  • Language Features: Serialisation; why the Cloneable interface sucks; exception handling; the immutability of Strings; the Object base class; primitive and object reference types; pass-by-value and pass-by-object-reference.
  • Design: The MVC Paradigm.
  • Swing: Framework basics; JFrames, JPanels and JComponents; Menus and menu handling; Trees and their nuances; File choosers, buttons, browser controls.

  Programming Drills (code-alongs, with source code included)

  • Serious stuff:
    • A daily stock quote summariser: scrapes the internet, does some calculations, and outputs a nice, formatted Excel spreadsheet.
    • A News Curation app to summarise newspaper articles into a concise email snippet using serious Swing programming
  • Simple stuff:
    • Support with choosing a programming environment; downloading and setting up IntelliJ.
    • Simple hello-world style programs in functional, imperative and object-oriented paradigms.
    • Maps, lists, arrays. Creating, instantiating and using objects, interfaces

  What am I going to get from this course?

  • Write Java programs of moderate complexity and sophistication (at an early to middling intermediate level)
  • Understand Object-Oriented programming concepts at the level where you can have intelligent design conversations with an experienced software engineer
  • Manage concurrency and threading issues in a multi-threaded environment
  • Create and modify files (including Excel spreadsheets) and download content from the internet using Java
  • Use Reflection, Annotations, Lambda functions and other modern Java language features
  • Build serious UI applications in Swing
  • Understand the Model-View-Controller paradigm, the Observer and Command Design patterns that are at the heart of modern UI programming
  • Understand the nuances of Java specific constructs in serialisation, exception-handling, cloning, the immutability of strings, primitive and object reference types

Who should buy this course?

• • Folks with zero programming experience - liberal arts majors, doctors, accountants, lawyers
  • Engineering students from non-CS majors looking to learn fairly serious programming
  • Computer Science students or software engineers with no experience in Java, but experience in Python, C++ or even C#. You might need to skip over some bits, but in general the class will still have new learning to offer you.

  What are the requirements?

  • No prior programming experience needed
  • The class will make use of Java and an IDE - never fear, we have a detailed video to walk you through the process of setting this up