Ending In:
$39
$740
Price Drop!
Courses
10
Lessons
561
Enrolled
3,543
Courses
10
Lessons
561
Enrolled
3,543
What's Included
From 0 to 1: Data Structures & Algorithms in Java
$49 Value
Byte Size Chunks: Java Model-View-Controller (MVC)
$24 Value
Byte Size Chunks: Java Reflection, Annotations and Lambdas
$24 Value
Byte Size Chunks: Java Object-Oriented Programming & Design
$24 Value
Byte Size Chunks: Java Multithreading
$24 Value
From 0 to 1: Design Patterns - 24 That Matter - In Java
$49 Value
From 0 to 1: JavaFX & Swing for Awesome Java UIs
$49 Value
Java Programming – the Master Course
$149 Value
Java Programming from Zero to Hero: Java Completed
$249 Value
The Ultimate Java 8 Tutorial - From Beginner to Professional
$99 Value
Product Details
Access
Lifetime
Content
11 hours
Lessons
66
From 0 to 1: Data Structures & Algorithms in Java
Master the Fundamentals of How Computer Programs Organize & Manipulate Data
By Loonycorn | in Online Courses
Data structures and algorithms? They're standard Computer Science 101 topics, and ones you'll master in this course. You'll learn how common data structures organize information so it can be used efficiently, how algorithms work to manipulate this data, and more. Though this course is tailored to the Java programming language, you'll emerge from it with a deep understanding of how any computer program works.
- Master data structures & algorithms w/ 11 hours of content
- Visualize common data structures & the algorithms applied to them
- Identify & apply which data structure or algorithm is optimal for a particular situation
- Calculate the time & space complexity of code
- Use the Big-O notation to perform complexity analyses on algorithms
- Understand how linked lists work
- Build a stack w/ Java, construct a queue, etc.
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- What this course is about
- You, This course and Us
- Data Structures And Algorithms - A Symbiotic Relationship
- Why are Data Structures And Algorithms important?
- Complexity Analysis and the Big-O Notation
- Performance and Complexity
- The Big-O Notation
- What is the complexity of these pieces of code?
- Linked Lists
- Linked Lists - The most basic of all data structures
- Linked List Problems
- Linked Lists vs Arrays
- Stacks And Queues
- Meet The Stack - Simple But Powerful
- Building A Stack Using Java
- Match Parenthesis To Check A Well Formed Expression
- Find The Minimum Element In A Stack In Constant Time
- Meet The Queue - A Familiar Sight In Everyday Life
- The Circular Queue - Tricky But Fast
- Build A Queue With Two Stacks
- Sorting and Searching
- Sorting Trade-Offs
- Selection Sort
- Bubble Sort
- Insertion Sort
- Shell Sort
- Merge Sort
- Quick Sort
- Binary Search - search quickly through a sorted list
- Binary Trees
- Meet The Binary Tree - A Hierarchical Data Structure
- Breadth First Traversal
- Depth First - Pre-OrderTraversal
- Depth First - In-Order and Post-Order Traversal
- Binary Search Trees
- The Binary Search Tree - an introduction
- Insertion and Lookup in a Binary Search Tree
- Binary Tree Problems
- Minimum Value, Maximum Depth and Mirror
- Count Trees, Print Range and Is BST
- Heaps
- The Heap Is Just The Best Way to Implement a Priority Queue
- Meet The Binary Heap - It's A Tree At Heart
- The Binary Heap - Logically A Tree Really An Array
- The Binary Heap - Making It Real With Code
- Heapify!
- Insert And Remove From A Heap
- Revisiting Sorting - The Heap Sort
- Heap Sort Phase I - Heapify
- Heap Sort Phase II - The Actual Sort
- Heap Problems
- Maximum Element In A Minimum Heap and K Largest Elements In A Stream
- Graphs
- Introducing The Graph
- Types Of Graphs
- The Directed And Undirected Graph
- Representing A Graph In Code
- Graph Using An Adjacency Matrix
- Graph Using An Adjacency List And Adjacency Set
- Comparison Of Graph Representations
- Graph Traversal - Depth First And Breadth First
- Graph Algorithms
- Topological Sort In A Graph
- Implementation Of Topological Sort
- Shortest Path Algorithms
- Introduction To Shortest Path In An Unweighted Graph - The Distance Table
- The Shortest Path Algorithm Visualized
- Implementation Of The Shortest Path In An Unweighted Graph
- Introduction To The Weighted Graph
- Shortest Path In A Weighted Graph - A Greedy Algorithm
- Dijkstra's Algorithm Visualized
- Implementation Of Dijkstra's Algorithm
- Introduction To The Bellman Ford Algorithm
- The Bellman Ford Algorithm Visualized
- Dealing With Negative Cycles In The Bellman Ford Algorithm
- Implementation Of The Bellman Ford Algorithm
- Spanning Tree Algorithms
- Prim's Algorithm For a Minimal Spanning Tree
- Kruskal's Algorithm For a Minimal Spanning Tree
- Implementation Of Kruskal's Algorithm
- Graph Problems
- Design A Course Schedule Considering Pre-reqs For Courses
- Find The Shortest Path In A Weighted Graphs - Fewer Edges Better
Access
Lifetime
Content
3 hours
Lessons
15
Byte Size Chunks: Java Model-View-Controller (MVC)
Use This Design Pattern to Easily Build & Test Complex Apps, Facilitate Group Development, and More
By Loonycorn | in Online Courses
Master the model-view-controller (MVC) view, and developing complex apps will be a breeze. This design pattern separates the code of different parts of an app: that which respectively handles the logic for app data, data display, and user interaction. You'll be able to focus on one aspect of development at a time, simplifying everything from building to testing your app and much more.
- Fully understand the Model-View-Controller (MVC) paradigm w/ 3 hours of content
- Learn about the Observer & Command Design patterns at the heart of modern UI programming
- See how MVC is used in Java, both in the Swing GUI widget toolkit & JavaFX software platform
- Implement event & menu handling using the Observer & Command design patterns
- Identify how MVC manifests itself in different UI programming use cases
- Understand how Properties & Bindings work
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
- Basic understanding of Java required
Course Outline
- Introduction
- You, This course and Us
- The MVC Paradigm
- The Model View Controller Design Pattern: An Introduction
- The Model View Controller Design Pattern In Action: A MediaPlayer Example
- The Model View Controller Design Pattern In Action: A Chart Example
- The Observer Pattern
- The Observer Design Pattern: Introduction
- The Observer Design Pattern In Action: Properties and Bindings - I
- The Observer Design Pattern In Action: Properties and Bindings - II
- The Observer Design Pattern In Action: Mouse Handling and Tree
- The Observer Design Pattern In Action: MVC + Observer = UI Magic
- The Observer Design Pattern In Action: A MediaPlayer Example - I
- The Command Pattern
- The Command Design Pattern
- The Command Design Pattern In Action: Lambda Functions - I
- The Command Design Pattern In Action: Lambda Functions - II
- The Command Design Pattern In Action: Threading
- The Command Design Pattern In Action: Undo and Logging
Access
Lifetime
Content
2 hours
Lessons
9
Byte Size Chunks: Java Reflection, Annotations and Lambdas
Master 3 Powerful Features to Take Your Java Expertise to the Next Level
By Loonycorn | in Online Courses
Take your Java skills to new heights by mastering three powerful features: reflection, annotations, and lambdas. You'll be able to apply code that can inspect other code in the same system, utilize metadata to learn about a program's properties, or craft blocks of code that you can calibrate to execute later--all tasks that will make you a more efficient, effective programmer than you thought possible.
- Master use of the Reflection, Annotation & Lambda features w/ 2 hours of content
- Know when it's appropriate to use reflection
- Use custom & built-in annotations to provide data on your code
- Use lambda functions to simplify your code & reduce bloat
- Chain together aggregate operations & lambda functions to benefit from powerful functional programming features available in Java
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: intermediate
Compatibility
- Internet required
- Basic Java knowledge required
Course Outline
- Introduction
- You, This course and Us
- 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
- Recursion, Reflection and Annotation
- Recursion
- Reflection: Not a Dark Art
- Reflection: A real use case
- Annotations: Notes to Self can be Super-Useful
Access
Lifetime
Content
7 hours
Lessons
38
Byte Size Chunks: Java Object-Oriented Programming & Design
Conquer Java with Just 7 Hours of Premium Instruction
By Loonycorn | in Online Courses
Java seems an appropriate name for a language that seems so dense, you may need a cuppa joe after 10 minutes of self-study. Luckily, you can learn all you need to know in this short course. You’ll scale the behemoth that is object-oriented programming, mastering classes, objects, and more to conquer a language that powers everything from online games to chat platforms.
- Learn Java inside & out w/ 7 hours of content
- Master object-oriented (OO) programming w/ classes, objects & more
- Understand the mechanics of OO: access modifiers, dynamic dispatch, etc.
- Dive into the underlying principles of OO: encapsulation, abstraction & polymorphism
- Comprehend how information is organized w/ packages & jars
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
- Basic Java knowledge required
Course Outline
- Start Here
- Introduction (2:11)
- An Object-Oriented State of Mind
- Objects are puppies
- Classes and Objects: An Object-Oriented State of Mind
- Static Variables and Methods
- Access Modifiers
- 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
- Runtime polymorphism
- The Object Base Class
- Interface: Introduction
- Interfaces vs Abstract Base Class
- Interfaces in Detail
- Interface Default Methods: Avoid Backward Compatibility Nightmares
- Interfaces and Inheritance in Action
- Java Language Constructs: The Best Thing Since Sliced Bread
- Exceptions
- The Immutability of Strings
- Object Identity: == and .equals()
- Generics: Type Safety and Code Re-use
- Collections: Containers for all purposes
- Generic Containers - much cooler
- Inner Classes: Horses for Courses - Static vs Non-Static
- Inner Classes: Horses for Courses - Anonymous and Local
- A serious drill with lots of code:-)
- 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
- Packages and Jars
- Jars: Not As Boring as They Might Seem
- Packages
- Packages and Jars in Action
- Some Object-Oriented Design Principles
- Design Principle #1: Rely on Interfaces, not Implementations
- Design Principle #2: The Open/Closed Principle
- Design Principle #3: The Principle of Least Knowledge
- Design Principle #4,5: Dependency Inversion and the Hollywood Principle
Access
Lifetime
Content
2 hours
Lessons
13
Byte Size Chunks: Java Multithreading
Learn to Write Efficient Programs That Execute Multiple Tasks Concurrently
By Loonycorn | in Online Courses
Add some serious firepower to your Java skills with multithreading, or the simultaneous execution of multiple tasks in the same program. Implement multithreading, and it's like you're putting multiple CPUs to work executing those tasks in your program. This is a powerful tool to amp up the performance of any program without completely draining precious computing resources.
- Master Java multithreading w/ 2 hours of content
- Fully understand the importance of threading in modern computing
- Master the basics: threads, processes, shared memory & inter-thread communication
- Dive into old-school Java threading: Runnable & Thread objects
- Delve into new-age threading: Callable & Future objects, executors, etc.
- Fully understand Java semantics
- Walk through a case study on double-checked locking & the singleton pattern
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- Introduction
- You, This course and Us
- 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
- New School Threading with Callables and Futures
- Digging Deeper into Callables and Futures
- Threading: New school fun in action
- Threading: Executors are pretty cool
- The Singleton Design Pattern
- The Singleton Design Pattern Introduction
- The Singleton Design Pattern: Double-Checked Locking
Access
Lifetime
Content
12 hours
Lessons
63
From 0 to 1: Design Patterns - 24 That Matter - In Java
Increase Your Coding Efficiency with 24 Tried-and-True Java Design Patterns
By Loonycorn | in Online Courses
Why reinvent the wheel when writing code? Meet the design pattern--a best practice applicable to a general problem that developers have faced during the development process. You'll learn about 24 design patterns applicable to Java, including the MVC paradigm, observer pattern, and more, to really take your coding efficiency to the next level.
- Dive into Java design patterns w/ 12 hours of content
- Identify situations that call for the use of a Design Pattern
- Understand each of 24 Design Patterns: when, how, why & why not to use them
- Distill the principles underlying Design Patterns, and apply these in coding and in life, whether or not a Design Pattern is needed
- Spot programming idioms that are actually built on Design Patterns, but that are now hiding in plain sight
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- What are Design Patterns?
- What this course is about
- Creational, Behavioural and Structural Paradigms
- Design Principle #1: Rely on Interfaces, not Implementations
- Design Principle #2: The Open/Closed Principle
- Design Principle #3: Principle of Least Knowledge
- Design Principles #4 and #5: Dependency Inversion and the Hollywood Principle
- A taste of things to come
- The Strategy Pattern
- The Strategy Design Pattern: Introduction via String Sorting
- The Strategy Pattern and Dependency Injection - I
- The Strategy Pattern and Dependency Injection - II
- The Decorator Pattern
- The Decorator Design Pattern
- The Decorator Design Pattern In Action: Java File APIs
- The Factory Pattern
- The Factory Design Pattern: Introduction
- The Factory Design Pattern In Action: Database Drivers
- The Abstract Factory Design Pattern
- The Abstract Factory Design Pattern: Families of classes
- The Factory Design Pattern In Action: Reflection - I
- The Factory Design Pattern In Action: Reflection - II
- The Singleton Pattern
- The Singleton Design Pattern: Introduction
- The Singleton Design Pattern: Double-Checked Locking
- The Singleton Design Pattern: The Synchronized Keyword
- The Singleton Design Pattern: Pulling together a multi-threaded solution
- The Adapter Pattern
- The Adapter Design Pattern: Introduction
- The Adapter Design Pattern: Introduction - II
- The Adapter Design Pattern In Action: Tables and Charts
- The Facade Pattern
- The Facade Design Pattern
- The Template Pattern
- The Template Design Pattern: Introduction via Text Auto-Summarization
- The Template Design Pattern In Action: Frameworks
- The Template Design Pattern In Action: Frameworks - II
- The Iterator Pattern
- The Iterator Design Pattern: Introduction
- The Iterator Design Pattern: Type Safety via Generics
- The Iterator Design Pattern: Internal and External Iterators
- The Iterator Design Pattern: Language Support for Iterators in Python and Java
- The MVC Paradigm
- The Model View Controller Design Pattern: An Introduction
- The Model View Controller Design Pattern In Action: A MediaPlayer Example
- The Model View Controller Design Pattern In Action: A Chart Example
- The Observer Pattern
- The Observer Design Pattern: Introduction (9:34)
- The Observer Design Pattern In Action: Mouse Handling and Trees
- The Observer Design Pattern In Action: MVC + Observer = UI Magic
- The Observer Design Pattern In Action: A MediaPlayer Example - I
- The Command Pattern
- The Command Design Pattern: Introduction (11:50)
- The Command Design Pattern In Action: Lambda Functions - I (9:51)
- The Command Design Pattern In Action: Lambda Functions - II (10:04)
- The Command Design Pattern In Action: Threading
- The Command Design Pattern In Action: Undo and Logging (14:39)
- The Composite Pattern
- The Composite Design Pattern: Introduction via Decorators
- The Composite Design Pattern: Class Hierarchy
- The Composite Design Pattern In Action: Transitions, Swing Containers
- The Builder Pattern
- The Builder Design Pattern: Introduction
- The Builder Design Pattern In Action: An SQL Query Builder I
- The Builder Design Pattern In Action: An SQL Query Builder II
- The Chain of Responsibility Pattern
- The Chain of Responsibility Design Pattern
- The Memento Pattern
- The Memento Design Pattern
- The Memento Design Pattern : Serialization
- The Visitor Pattern
- The Visitor Design Pattern
- The State Pattern
- The State Design Pattern
- The State Design Pattern in Action : Mediaplayer
- The Flyweight Pattern
- The Flyweight Design Pattern
- The Flyweight Design Pattern : Multithreading
- The Bridge Pattern
- The Bridge Design Pattern
- The Mediator Pattern
- The Mediator Design Pattern
- The Prototype Pattern
- The Prototype Design Pattern
- The Proxy Pattern
- The Proxy Design Pattern
Access
Lifetime
Content
12 hours
Lessons
49
From 0 to 1: JavaFX & Swing for Awesome Java UIs
Utilize These Graphical User Interface Libraries to Easily Create Multiplatform Apps
By Loonycorn | in Online Courses
If JavaFX and Swing aren't in your development toolbox, they should be. These graphical user interface libraries are powerful tools that will expedite UI design in your Java applications. Think buttons, bar charts, date pickers, and more--any features that users will use to interact with your app.
- Build sophisticated user interfaces in Java w/ 12 hours of content
- Master use of the JavaFX & Swing GUI libraries
- Utilize UI-building techniques & tools: menus, trees, buttons, tables, etc.
- Use Scenebuilder & FXML to effortlessly create UIs w/ dependency injection
- Utilize properties & bindings
- Draw shapes & nodes, render 3D images & animations, etc.
- Understand the design patterns that underpin nearly all modern UI frameworks
Loonycorn is comprised of four individuals—Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh—who have honed their tech expertises at Google and Flipkart. The team believes it has distilled the instruction of complicated tech concepts into funny, practical, engaging courses, and is excited to be sharing its content with eager students. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- Why learn JavaFX and Swing?
- Introduction
- Swing
- The Basic Idea of Swing
- The Mechanics of Swing I
- The Mechanics of Swing-II
- JavaFX Introduced
- Contrasting JavaFX and Swing - I
- Contrasting JavaFX and Swing-II
- The Mechanics of JavaFX
- Properties and Bindings Introduced
- We are in sync : Properties and Bindings in action
- Properties And Bindings
- Properties and Bindings: Digging Deeper
- Properties and Bindings: Observables, ChangeListeners and Other Interfaces
- JavaFX: Modeling Properties and Bindings
- JavaFX : Digging into Bindings
- The trick to JavaFX properties: Lazy Instantiation
- FXML and SceneBuilder
- Complex UIs via FXML and SceneBuilder
- FXML Behind the Scenes : Linking to the controller
- FXML Behind the Scenes : Dependency Injection
- The Full Possibilities of FXML - I
- The Full Possibilities of FXML - II
- The Full Possibilities of FXML - III
- Shapes and Drawing
- Drawing: Shapes and Nodes
- Drawing: Fonts and a Segue into Animated GIFs
- Animation
- Animation: Timelines and Transitions
- Transitions Explored
- Media
- JavaFX Media Support: Part-Lame, Part-Awesome
- JavaFX Media Support: Getting started with common operations
- Build your own Media Player - I
- Build your own Media Player - II
- Charts and Tables
- JavaFX Charts and Tables - I
- JavaFX Charts and Tables - II
- Charts and Tables : An example - I
- Charts and Tables : An example - II
- 3D
- 3D Rendering : Introduction to 3D Rendering: Segue to Drawing in 2D
- Introduction to 3D Rendering
- 3D Rendering: Getting our feet wet
- 3D Animations: Timelines and Moving Cameras
- Swing Practical Exercises
- 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
- JavaFX Practical Exercise
- How the MVC Paradigm Shapes JavaFX Apps
- A Serious JavaFX App: The News Curator - I
- A Serious JavaFX App: The News Curator - II
- FXML Practical Exercises
- Building a Serious UI App with FXML and SceneBuilder: Snippet Browser - I
- Building a Serious UI App with FXML and SceneBuilder: Snippet Browser - II
- Building a Serious UI App with FXML and SceneBuilder: Snippet Browser - III
- Properties and Bindings Practical Exercises
- Properties and Bindings: Coding examples
- A Zippier UI using Properties and Bindings: Snippet Browser with a Real-Time Pre
- Recap
- Class Recap
Access
Lifetime
Content
9 hours
Lessons
88
Java Programming – the Master Course
Get Premium, Step-By-Step Instruction on All Things Java
By Huw Collingbourne | in Online Courses
Java is undoubtedly one of the most important programming languages out there, and learning it doesn't have to be a chore. This course will have you up to speed in no time, covering programming basics applicable to all languages, Java fundamentals, and much more.
- Master the fundamentals of Java: data types, variables, constants, etc.
- Understand the principles of object-oriented programing
- Utilize conditional tests & operators, arrays & collections, loops, etc.
- Delve into advanced topics: enumerated types, interfaces & scope
- Use generics & exceptions to detect bugs & handle errors
- Handle files & serialize objects
Huw Collingbourne runs Bitwise Courses and teaches courses on a range of programming topics. He is also the technology director at SapphireSteel Software, a company which makes tools for Microsoft Visual Studio. Huw has been a programmer for more than 30 years and is a well-known technology writer in the UK, having written numerous opinion and programming columns for publications such as Computer Shopper and Flash & Flex Developer’s Magazine. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- Getting Started
- Welcome to this course
- Install Java and NetBeans
- What is Java?
- Source Code Archive
- The Little Book Of Java
- Quiz Questions - self-assessment (download)
- Quiz Answers (download)
- How to use the demo projects in NetBeans
- First Steps in Java
- A first program – Hello world
- Making sense of Java code
- How to open a command prompt in Windows and the Mac
- How to pass arguments to a program
- How to create visual applications
- Compiling Java programs – from source code to bytecode
- Printing text at the system prompt
- Displaying text in visual controls
- The Fundamentals of Java Programming
- Data Types and Variables
- Constants
- Design and program a calculator in NetBeans
- Packages and imports
- Type conversion
- Primitives and wrappers
- Type casts
- Numeric literals
- Automatic string conversions
- Autoboxing and unboxing
- Strings
- Object Orientation
- What is Object Orientation?
- Classes and objects
- Class hierarchies
- How to create a subclass
- Methods
- Static methods and variables
- Conditional Tests and Operators
- Operators
- Arithmetic operators
- String equality
- String equality – exceptions to the rule!
- if..else tests
- switch..case
- Logical operators and Booleans
- Compound assignment operators
- Unary addition and subtraction operators
- Arrays and Collections
- Arrays
- Zero-based arrays
- Initializing arrays
- for loops
- Garbage collection
- ArrayLists
- Interfaces
- Generics
- Maps
- Type-safe HashMaps
- Loops
- for loops revisited
- Enhanced for statements
- while
- while loop to read text file
- do..while
- Multidimensional arrays
- Iterating over multidimensional arrays
- break
- continue
- Disadvantages of break and continue
- Breaking out of a nested for loop
- Labelled break
- Enumerated types, interfaces and scope
- Enums
- Enums and static constants
- The Enum class
- Debugging code
- Interfaces
- A custom interface
- Scope
- Local variables
- Access modifiers
- Generics and Exceptions
- Introducing Generics
- Strongly-typed lists
- Generic type parameters
- Generic classes
- Generic collections
- Overriding methods
- Overloading methods
- Exceptions
- Catching exceptions
- Exception types
- Files and Serialization
- File-handling
- Random access files
- Streams
- Serialization
- Saving serialized objects to disk
- Restoring serialized objects from disk
- And finally...
Access
Lifetime
Content
4 hours
Lessons
48
Java Programming from Zero to Hero: Java Completed
Jumpstart Your Java Journey in Under 4 Hours
By University of Geeks | in Online Courses
Delve into this powerful general purpose programming language to understand a technology that powers much of the Internet--games, online chat features, and more. You'll master everything from Java syntax to general object-oriented programming principles, and will establish a solid Java programming foundation by course's end.
- Get an overview of Java fundamentals w/ 4 hours of content
- Become comfortable w/ Java syntax: variables, objects & classes, and more
- Utilize strings & arrays, methods, and more
- Master object-oriented programming concepts: inheritance, abstraction, etc.
- Dive into advanced Java principles: data structures, collections & more
- Efficiently write Java code by the end of your lessons
University of Geeks is a team of developers that wants to help and inspire others to learn development. This four-person team collectively possesses 3 Bachelor's degrees in Computer Science, a Bachelor's in Design, and around 15 years of experience coding and teaching. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- Java Programming : The Introduction
- Brief Overview of the Course (3:23)
- Introduction & History of Java (2:22)
- Features of Java (6:51)
- Set Up I.D.E.
- Basic Syntax (3:56)
- Section 1 Readables
- Java Programming : Building Blocks of Java
- Constant & Variables (3:15)
- Data types, Identifiers &Java Modifiers (6:42)
- Objects & Classes (3:28)
- Section 1 Hands On : Hello, Udemy (Assignment )
- Hands On: Hello, Udemy | Code Along (3:22)
- Section 2 Readables
- Java Programming : Operators , Loops and Decisions
- Arithmetic Operators, Relational Operators, Bitwise Operators, Logical Operator
- Precedence of Java operator
- For loop, While loop, Do while loop (5:49)
- If statement , If...else, Nested if statement and Switch statement (4:52)
- Section 3 Hands On Part 2 : The Inventory System (Assignment )
- Hands On: Inventory System | Code Along (9:56)
- Java Programming : Strings and Arrays
- Strings
- Array & Multidimensional array (8:08)
- Section 4 Hands On : Palindrome (Assignment )
- Hands On: Palindrome | Code Along (8:34)
- Java Programming : Methods Exceptions and File Streaming
- Methods
- Exception handling
- File Streaming
- Inner Class
- Section 5 Hands On : Grading System (Assignment )
- Hands On : Graded Assignment | Code Along (6:25)
- Java Programming : Object Orientated
- Inheritance (5:51)
- Polymorphism
- Abstraction (8:08)
- Encapsulation (4:30)
- Package (10:34)
- Interface (5:42)
- Section 6 Hands On : The Multiplication Project (Assignment )
- Hands On: Multiplication | Code Along (5:17)
- Java Programming : Advanced
- Data Structures | Part One
- Data Structures | Part Two (10:17)
- Collections (10:06)
- Serialization (4:21)
- Multi-Threading | Part One
- Section 7 Hands On : Gas Mileage Calculator (Assignment )
- Multi-Threading | Part Two (3:56)
- Swing (9:32)
- Session Handling, Hidden fields, Http Session, Cookies (4:02)
- Java Programming : The Final Exams
- Final Project (Assignment )
- Java Programming : The Wrap Up
- What To Do Next
- Thank You!!!!!!!!!!!!!!
Access
Lifetime
Content
20 hours
Lessons
172
The Ultimate Java 8 Tutorial - From Beginner to Professional
Master All You Need to Know About Java with This Comprehensive 20-Hour Course
By Learning Kart | in Online Courses
Conclude your Java journey with this comprehensive course on Java 8. With hundreds of lectures spanning everything from setting up your programming environment to utilizing loops, arrays, and methods, you'll be certain to achieve complete Java mastery by the time the clock winds down on the final seconds of your last lesson.
- Learn Java 8 inside & out w/ 20 hours of content
- Understand the history of the Java language & how it functions
- Install the Java SDK to set up your programming environment
- Delve into the basics of Boolean & integer data types
- Master use of different operators: arithmetic, unary, etc.
- Utilize loops in Java: if-else, for-loop, etc.
- Implement object-oriented programming concepts: inheritance, polymorphism, etc.
LearningKart is a premier destination for students to learn and upgrade their skills. It comprises a team of professional trainers with expertise in the Java development, Android, and other web technologies. For more details on the course and instructor, click here.
This course is hosted by StackSkills, the premier eLearning destination for discovering top-shelf courses on everything from coding—to business—to fitness, and beyond!
Details & Requirements
- Length of time users can access this course: lifetime access
- Access options: web streaming, mobile streaming
- Certification of completion not included
- Redemption deadline: redeem your code within 30 days of purchase
- Experience level required: all levels
Compatibility
- Internet required
Course Outline
- Java - How it all Started and Language Basics
- History of the Java Language
- How Java Works
- Installing the SDK -Arranging the Nuts and Bolts
- Installing Java SDK and File Structure of Installation
- Coding Exercise -1 : My first Java Program on Notepad
- Coding Exercise -2 : My first Java Program on Eclipse
- Coding Exercise -3 : Learning more about classes
- Code practice - learn by doing
- Language Basics : What you must know from start
- Numbers representation in Binary
- Representation of Negative Numbers
- Signed and Unsigned variables
- Practice the Code
- Data types in Java
- Java Data Types - boolean - the basic one
- Java Data types - integer data types
- Java Data types - integer - different representations - decimal, octal
- Java Data types - integer - different representations - hexadecimal and binary
- Char data type
- Character representation in Java - contd
- Floating point data type in Java
- Floating point data type in Java - contd
- Variable naming conventions
- Literals values in Java
- Using underscores in Variable Values in java 8
- Casting of data types
- Casting in Java - contd
- Operators - the roots of every language arithmetics
- Arithmetic Operators
- Unary Operators
- Increment and Decrement operators
- Relational Operators
- Bitwise Operators
- Shift Operators
- Assignment Operators
- Precedence & Associativity
- Loops in Java - What controls the flow
- The if-else loop
- Multiple if-else loop
- Logical operators AND and OR
- Switch Case Loop
- The for-loop basics
- The for-loop in depth
- Multiple for-loops
- Details of while loop
- Anatomy of Break and Continue
- Practice Questions for Section -5
- Arrays - Storing many at a time
- Arrays defined and one dimensional arrays
- The for-each loop
- Multidimensional Arrays
- Practice Questions for Section - 6
- Classes & objects - the lifeline of OOps
- Classes structure and format
- Instance and Static variables
- Instance and static methods
- Methods and passing parameters to Methods
- Defining Methods
- Variable parameter passing to methods
- Pass by Value and Pass by reference
- OOPs concepts - continuing the legacy
- Encapsulation - hiding of data
- Encapsulation - Continued
- Polymorphism - same name different results
- Constructors : the starting point of an object
- Why we require Constructors
- Constructor overloading
- Passing objects to constructors
- The Initialization block
- The final keyword
- Wrapper Classes and Garbage Collection
- Wrapper Classes
- Command Line Arguments
- Garbage Collection in Java
- Strings - the nuts and bolts of programming
- Basics of Strings
- String Methods
- Comparing strings with equals and ==
- Effectively using string methods - code examples
- The StringBuffer class
- StringTokenizer - breaking String into Tokens
- Practice Questions
- Inheritance - extending the code
- Inheritance - how inheritance works
- The super keyword
- Grand super class - Object class
- Why no multiple inheritance
- Final Methods and classes
- Polymorphism - when things are known at runtime
- Access modifiers in java
- Overriding methods in Inheritance
- Object casting explained
- Object casting continued
- Runtime Polymorphism - the essence of java
- Runtime Polymorphism - in effect
- The instanceof operator
- Determining the type of object
- Interfaces - where everything is hidden
- Declaring Interfaces and multiple inheritance
- Interfaces Continued
- Defaut methods in Interfaces - Added in Java8
- Multiple Inheritance with default methods
- Inner Classes - Mystery revealed
- Why Inner Classes & Types
- Member class
- Inner classes uncovered
- In depth on implementing inner classes
- Inheriting Inner classes
- Local inner classes
- Anonymous Classes
- Enumerations in Java
- Basics of Enumerations
- Working with Enumerations
- What Enumerations are Compiled to
- Working with fields, Constructors and Methods in Enums
- Adding abstract methods to enum
- Source Code
- The all New Date amd Time API : The overhaul was long due
- Date and Calendar class - how it worked earlier
- Calendar class in detail
- Generating Random Numbers (10:42)
- New Date and Time API - Instant class
- Working with Instant class
- Working with Instant class - continued
- The Date-Time Classes in the java.time package
- The LocalDate class - learning about dates
- LocalDate - using methods of LocalDate
- LocalDate - more methods
- Using Adjusters with LocalDate
- Code Example - learning to use LocalDate
- More Classes in the Package - MonthDay , YearMonth
- Code Practice Example -2
- Date Time Formatting - Take things in your own hand
- Source Code to Download
- Code to Practice
- Packages : Grouping code together
- Why packages and setting classpath
- Accessing package classes and methods
- Importing packages
- Arranging classes with javac
- Exception Handling : When things go wrong
- Exception Handling explained
- Using try/catch effectively
- More on try/catch
- Nested Try / Catch
- Using the finally block
- Passing Exceptionw with throws
- Checked v/s Unchecked Exceptions
- How to throw Exceptions
- Creating own Exceptions
- Method overriding with Exceptions
- finally in more detail
- Collections : Elements Unlimited
- Why Collections and Vector class explained
- LinkedList - how it works and details
- ArrayList - declaration and usage
- HashSet - avoid duplicates with Set
- HashMap - Basics and working
- HashMap - More Options Explored
- HashMap - how it stores objects
- Input/Output using Streams - Lifeline for data handling
- Basics of Java I/O and Streams
- Reading from Console with System.in
- Reading from console with Scanner class
- Handling data with Scanner class
- Using Console class for console input
- Using the File Class
- Methods of File Class
- Reading and Writing Files
- Buffering Input / Output
- Creating copycon program
- Redirecting Streams
- Dealing with data types using DataInputStream/DataOutputStream
- DataInputStream/DataOutputStream continued
- Serialization - basics explained
- Serialization - in depth
- Serialization - in depth continued
- Creating a zip file in java
- Extracting a zip file in java
- Creating a jar file in Java
- Creating jar file - continued
- Using Try Block with Resources
- Practice Questions
- Lambda Expressions - the new hype in Java 8
- Basics of Lambda Expressions - starting a new path
- Learning more on Lambda Expressions
- Using Annotations and return types with Lambda Expressions
- Using static and instance variables within lambda expressions
- Using Generics with lambda expressions
- Method references - the new way to call methods
- Using Exceptions with Lambda Expressions
- Using Generics with Method References
- Test your Practice Here
- Project
- Conclusion
- Conclusion - The new begining
Terms
- Unredeemed licenses can be returned for store credit within 30 days of purchase. Once your license is redeemed, all sales are final.