From 0 to 1: Learn Java Programming -Live Free,Learn To Code
Taught by a Stanford-educated, ex-Googler, husband-wife team
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!
A Java course for everyone – accessible yet serious, to take you from absolute beginner to an early intermediate level
Let’s parse that.
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.
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; properties and bindings too. Also detailed coverage of Futures and Callables, as well as of Lambda functions, aggregation operators. JavaFX as contrasted with 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, Observer and Command Design Patterns.
Swing: Framework basics; JFrames, JPanels and JComponents; Menus and menu handling; Trees and their nuances; File choosers, buttons, browser controls. A very brief introduction to JavaFX.
Programming Drills (code-alongs, with source code included)
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
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
Talk to us!
Mail us about anything – anything! – and we will always reply 🙂
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
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
Gain a superficial understanding of JavaFX and Properties and Bindings
Understand the nuances of Java specific constructs in serialisation, exception-handling, cloning, the immutability of strings, primitive and object reference types
What is the target audience?
Yep! Folks with zero programming experience – liberal arts majors, doctors, accountants, lawyers
Yep! Engineering students from non-CS majors looking to learn fairly serious programming
Nope! Experienced Java programmers – this class will be boring for you:)
Yep! 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 🙂
|Section 1: You, Us & This Course|
|Section 2: Coding Is Like Cooking|
Coding is like Cooking
Functions as Food Processors
Installing Java and Setting up an IDE
Variables – Primitives, Objects, Null
Hello World! (Drill)
Don’t Jump Through Hoops, Use Loops
Arrays and Lists – Drill
Maps – Drill
|Section 3: An Object-Oriented State of Mind|
The Evolutionary Arc from C, through C++, to Java
Objects are like puppies
Classes and Objects: An Object-Oriented State of Mind
Static Variables and Methods
Classes and Objects: A Simple Example I
Classes and Objects: A Simple Example II
Is-A Inheritance – setting up a class hierarchy
Is-A Inheritance – parent class, child class relationship
The Object Base Class
Interfaces : Introduction
Interfaces vs Abstract Base Class
Interfaces and Abstract Base Classes
Interfaces In Detail
Interface Default Methods: Avoid Backward Compatibility Nightmares
Interfaces and Inheritance in Action
Classes and Objects
Classes and Objects
Output of functions
|Section 4: Java Language Constructs: The Best Thing Since Sliced Bread|
Object Identity: == and .equals()
Generics: Type Safety and Code Re-use
Collections: Containers for all purposes
Generic Containers – much cooler
Ordered Associative Containers – The Tree Map
Inner Classes: Horses for Courses – Static vs Non-Static
Inner Classes: Horses for Courses – Anonymous and Local
Static and non-static nested classes
Static nested classes
A File is like a Barrel
A Serious Java Application: Our First
A Serious Java Application: Parsing Stock Ticker Data – I
A Serious Java Application: Parsing Stock Ticker Data – II
A Serious Java Application: Parsing Stock Ticker Data – III
A Serious Java Application: Parsing Stock Ticker Data – IV
A Serious Java Application: Parsing Stock Ticker Data – V
|Section 5: Threading and Concurrency: A Lot Going On All At Once|
Threading, and Why It Matters
Threading: Old school vs New school
Traditional Threading Support
Threading and Concurrency: A lot going on at once
Synchronized Methods, Livelock, Deadlock and Starvation
Working with threads – and our first synchronization bug!
Threads: Object locking and static variables in action
Digging Deeper into Callables and Futures
Threading: New school fun in action
Threading: Executors are pretty cool
|Section 6: Functional Programming: Crossover Hits|
Functional Programming: A State of Mind
Lambda Functions: A Crossover Hit
Lambda Functions: No more boiler-plate code
Lambda functions for real – in code
|Section 7: Recursion, Reflection, Annotations, Dates, Packages and Jars|
Reflection: Not a Dark Art
Reflection: A real use case
Annotations: Notes to Self can be Super-Useful
Question 24 – Annotation
Working With Dates in Java
Jars: Not As Boring as They Might Seem
Packages and Jars in Action
Compiling and building Java code
The Immutability of Strings
|Section 8: UI Programming: Swing, MVC, and JavaFX|
Frameworks – A State of Mind
The Basic Idea of Swing
Swing and the Model-View-Controller Paradigm
The Mechanics of Swing – I
The Mechanics of Swing – II
A Serious Swing App: News Curation Browser – I
A Serious Swing App: News Curation Browser – II
A Serious Swing App: News Curation Browser – III
A Serious Swing App: News Curation Browser – IV
Observers, Events and Listeners
Actions, And The Command Design Pattern
A Peek at JavaFX – I
A Peek at JavaFX – II
Properties And Bindings
Properties And Bindings In Action
|Section 9: Some Interview Problems For Practice!|
Starting up – palindromes and points within a distance
Play the Game Of Life and Break A Document Into Chunks
Implement paint fill to color a region on screen
Loony Corn, A 4-person team;ex-Google; Stanford, IIM Ahmedabad, IIT
Loonycorn is us, Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh. Between the four of us, we have studied at Stanford, IIM Ahmedabad, the IITs and have spent years (decades, actually) 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
Swetha: Early Flipkart employee, IIM Ahmedabad and IIT Madras alum
Navdeep: longtime Flipkart employee too, and IIT Guwahati alum
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 🙂
- Lectures 0
- Quizzes 0
- Duration 50 hours
- Skill level All level
- Language English
- Students 1578
- Assessments Self