skillzpot logo
preview
lessons
82
duration
16:31:04
language
English
level
beginner
access
lifetime

Learn Java Programming _ Beginner to intermediate Level

By
Loony Corn
Posted
2017-02-14
Filmed by
Self
800
400

Overview

A Java course for everyone - accessible yet serious, to take you from absolute beginner to an early intermediate level. 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. 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. 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.

Is this course for me?

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.

What will I gain 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.

How do I prepare before taking this course? Is there a prerequisite skill set?

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.

  • Lesson 1

    Coding is like Cooking

  • Lesson 2

    Functions as Food Processors

  • Lesson 3

    Installing Java and Setting up an IDE

  • Lesson 4

    Variables - Primitives, Objects, Null

  • Lesson 5

    Hello World!

  • Lesson 6

    Don't Jump Through Hoops, Use Loops

  • Lesson 7

    Arrays and Lists - Drill

  • Lesson 8

    Maps

  • Lesson 7

    Maps - Drill

  • Lesson 8

    The Evolutionary Arc from C, through C++, to Java

  • Lesson 9

    Objects are like puppies

  • Lesson 10

    Classes and Objects: An Object-Oriented State of Mind

  • Lesson 11

    Static Variables and Methods

  • Lesson 12

    Access Modifiers

  • Lesson 13

    Classes and Objects: A Simple Example I

  • Lesson 14

    Classes and Objects: A Simple Example II

  • Lesson 15

    Is-A Inheritance - setting up a class hierarchy

  • Lesson 16

    Is-A Inheritance - parent class, child class relationship

  • Lesson 17

    Runtime Polymorphism

  • Lesson 18

    The Object Base Class

  • Lesson 19

    Interfaces : Introduction

  • Lesson 20

    Interfaces vs Abstract Base Class

  • Lesson 21

    Interfaces In Detail

  • Lesson 22

    Interface Default Methods: Avoid Backward Compatibility Nightmares

  • Lesson 23

    Interfaces and Inheritance in Action

  • Lesson 24

    Java Language Constructs: The Best Thing Since Sliced Bread

  • Lesson 25

    Object Identity: == and .equals()

  • Lesson 26

    Collections: Containers for all purposes

  • Lesson 27

    Generic Containers - much cooler

  • Lesson 28

    Ordered Associative Containers - The Tree Map

  • Lesson 29

    Inner Classes: Horses for Courses - Static vs Non-Static

  • Lesson 30

    Inner Classes: Horses for Courses - Anonymous and Local

  • Lesson 31

    A File is like a Barrel

  • Lesson 32

    A Serious Java Application: Our First

  • Lesson 33

    A Serious Java Application: Parsing Stock Ticker Data - I

  • Lesson 34

    A Serious Java Application: Parsing Stock Ticker Data - II

  • Lesson 35

    A Serious Java Application: Parsing Stock Ticker Data - III

  • Lesson 36

    A Serious Java Application: Parsing Stock Ticker Data - IV

  • Lesson 37

    A Serious Java Application: Parsing Stock Ticker Data - V

  • Lesson 38

    Threading and Concurrency: A Lot Going On All At Once

  • Lesson 39

    Threading: Old school vs New school

  • Lesson 40

    Traditional Threading Support

  • Lesson 41

    Threading and Concurrency: A lot going on at once

  • Lesson 42

    Synchronized Methods, Livelock, Deadlock and Starvation

  • Lesson 43

    Working with threads - and our first synchronization bug!

  • Lesson 44

    Threads: Object locking and static variables in action

  • Lesson 45

    Digging Deeper into Callables and Futures

  • Lesson 46

    Threading: New school fun in action

  • Lesson 47

    Threading: Executors are pretty cool

  • Lesson 48

    Functional Programming: A State of Mind

  • Lesson 49

    Lambda Functions: A Crossover Hit

  • Lesson 50

    Lambda Functions: No more boiler-plate code

  • Lesson 51

    Lambda functions for real - in code

  • Lesson 52

    Recursion

  • Lesson 53

    Reflection: Not a Dark Art

  • Lesson 54

    Reflection: A real use case

  • Lesson 55

    Annotations: Notes to Self can be Super-Useful

  • Lesson 56

    Working With Dates in Java

  • Lesson 57

    Jars: Not As Boring as They Might Seem

  • Lesson 58

    Packages

  • Lesson 59

    Packages and Jars in Action

  • Lesson 60

    Serialisation

  • Lesson 61

    Cloning

  • Lesson 62

    The Immutability of Strings

  • Lesson 63

    UI Programming: Swing, MVC, and JavaFX

  • Lesson 64

    The Basic Idea of Swing

  • Lesson 65

    Swing and the Model-View-Controller Paradigm

  • Lesson 66

    The Mechanics of Swing - I

  • Lesson 67

    The Mechanics of Swing - II

  • Lesson 68

    A Serious Swing App: News Curation Browser - I

  • Lesson 69

    A Serious Swing App: News Curation Browser - II

  • Lesson 70

    A Serious Swing App: News Curation Browser - III

  • Lesson 71

    A Serious Swing App: News Curation Browser - IV

  • Lesson 72

    Observers, Events and Listeners

  • Lesson 73

    Actions, And The Command Design Pattern

  • Lesson 74

    A Peek at JavaFX - I

  • Lesson 75

    A Peek at JavaFX - II

  • Lesson 76

    Properties And Bindings

  • Lesson 77

    Properties And Bindings In Action

  • Lesson 78

    Starting up - palindromes and points within a distance

  • Lesson 79

    Play the Game Of Life and Break A Document Into Chunks

  • Lesson 80

    Implement paint fill to color a region on screen

profile pic

Loony Corn

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 hope you will try our offerings, and think you'll like them.

you might also like