$50
Certification

Industry recognized certification enables you to add this credential to your resume upon completion of all courses

Need Custom Training for Your Team?
Get Quote
Call Us

Toll Free (844) 397-3739

Inquire About This Course
Instructor
Marcos Costa, Instructor - Comprehensive Java: From Beginner to Advanced

Marcos Costa

Marcos has a Bachelor's degree in Industrial Design, been developing software for the past 17 years. He worked for Nextel Telecom, Ford Motors, The Australian Government and Editora Abril.

Instructor: Marcos Costa

Learn Java from the basics and go deeper with algorithms and data structures

  • Learn everything about Java-from installation and coding to algorithms and data structures.
  • No technical expertise needed.
  • Instructor has 17 years of experience working for Nextel Telecom, Ford Motors & The Australian Government 

Course Description

You will learn how to develop using Java from the beginning. We will use Eclipse, Java 8, Maven and JUNIT and a little bit of imagination to create fun exercises so you don't get bored. We will jump right into the fun stuff. First we will install what is necessary, then start coding and understand the principles of Java as we do it. At the end of the beginners part of this course you will be able to develop small application in Java using clean and solid code. After leaning how to develop in Java from the beginning we will jump to algorithms and data structures We will code together the following algorithms: Euclid, Linear Search, Insert Sort, Binary Search, Quick Sort and for data structures we will code the following: Binary Tree, Linked List, Doubly Linked List, Prefix Tree or Trie Tree, Stack Finally some coding interview questions Print Odd Numbers, Longest Substring Without Repeating Character (Amazon Question), Sudoku (Amazon Question) This is not just one of the most feared subjects in the computer science world but it is also one of the hottest topics. algorithms and data structures are very important topics since your choice of algorithm and data structure will affect memory and CPU time differently. This topic will also help your daily coding as it did to me. There are hundreds of different algorithms and data structures but we will cover just a few of the most popular and one that might help you on your current project.

What am I going to get from this course?

  • Prepare the development environment to work with Java
  • Learn the Java Language
  • Learn the most popular algorithms and data structures
  • Write algorithms and data structures with confidence
  • Think out of the box when solving daily problems
  • Understand the importance of unit testing your application
  • Get a basic understanding of Maven
  • Learn how recursion works
  • Practice with some interview coding questions
  • Code a Sudoku solver
     

Prerequisites and Target Audience

What will students need to know or do before starting this course?

Internet connection and a computer 

Who should take this course? Who should not?

  • Anyone interested in learning Java
  • Learning and/or improving the algorithms and data structure skills
  • Preparing for an interview
     

Curriculum

Module 1: Installation and Setup

Lecture 1 Eclipse Installation

In this lecture, we will download and install eclipse so that we can get started with our next lecture. If you already have eclipse installed or you want to use your own editor then skip to the next lecture.

Lecture 2 Create the First Project

In this lecture, we will create a Maven project and run through Eclipse. You will get familiar with the IDE that we will use to develop, debug and execute.

Module 2: Learning Java

Lecture 3 Creating Packages

In this lecture, we will create a Maven project and do a quick run through Eclipse for you to get familiar with the IDE that we will use to develop, debug and execute.

Lecture 4 Classes

In this lecture, you will learn what a Class is. I will teach you what the structure of a class and we will also create a class with a constructor.

Lecture 5 Attributes and Constants

In this lecture, you will learn and code attributes and constants

Lecture 6 Methods

In this lecture, you will understand what the methods are for. We will code a few of them and also implement another class with more methods. You will be able to understand the link that the method does between classes and attributes.

Lecture 7 Primitive Types and Reserved Words in Java

In this lecture, you will learn about the reserved words and all the primitive types which are used as a type of variables in Java.

Lecture 8 Operators

In this lecture, you will learn the java operators. including: Arithmetic Operators Relational Operators Logical Operators Assignment Operators Conditional Operator Instance Operator

Lecture 9 Decision Making - if condition

This lecture will teach you about if else condition.

Lecture 10 Loop Control

In this lecture, you will learn about for, while and do-while loops

Lecture 11 Methods and Hierarchy 1 of 4 Implementation Plan

This lecture is a presentation of what we are going to develop. It also contains a basic UML which will explain what we will accomplish with the classes that we are designing. There are 3 more lectures after this one with just coding

Lecture 12 Methods and Hierarchy 2 of 4

In this lecture, we will code what was planned on the previous lecture. The coding will extend for 2 more lectures after this one. We will implement multiple classes and connect all of them together either using just creating an instance or inheriting from a super class

Lecture 13 Methods and Hierarchy 3 of 4

In this lecture, we will continue coding our Pizza application started on the lecture 8. The next lecture will be the last lecture of the sequence for hierarchy. Using extends and polymorphism to use the Crust and the Topping

Lecture 14 Methods and Hierarchy 4 of 4

In this lecture, we will finish the implementation of our Pizza. It will calculate the total price for the pizza. The total calories was not implemented on purpose. Go ahead and implement it using the total price as a guide for you. Feel free to contact me and I will be glad to help.

Lecture 15 Memory and Garbage Collector

In this lecture, you will learn how Java memory works. I will also introduce the GC - Garbage Collector

Lecture 16 The List and ArrayList

In this lecture, we will use List and ArraysList as opposed as normal arrays []

Lecture 17 Dealing with Exceptions - Try, Catch and Finally

In this lecture, we you will learn how to deal with error. We will talk about Exceptions and how to catch them. We will also code try, catch finally blocks

Lecture 18 Wrapper Classes

In this lecture, you will learn what are wrapper classes. We will write code to test a couple of them and I will show you all the available ones

Lecture 19 Maven

In this lecture, you will have a high level understanding of what maven does and how to download external packages and include to your project using maven.

Lecture 20 Cast objects

In this lecture, you will understand what is Cast and why to use it.

Lecture 21 JUNIT

In this lecture, you will learn how to create a unit test from scratch using junit. You will learn how to use Assertions and execute the test on multiple packages at once

Module 3: The Parking Lot Exercise

Lecture 22 Parking lot development part 1 of 4

This lecture is the first part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.

Lecture 23 Parking lot development part 2 of 4

This lecture is the second part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.

Lecture 24 Parking lot development part 3 of 4

This lecture is the third part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.

Lecture 25 Parking lot development part 4 of 4

This lecture is the forth part out of four and we will apply what you have learned so far. We will develop together a parking lot with levels and parking spaces. We will also be able to park cars into an empty space.

Module 4: Get Started With Algorithms and Data Structure

Lecture 26 Euclid's algorithm with Recursion

It will be easier to show how recursion works implementing an algorithm. We will implement Euclid's algorithm. I incentive you to write the code a few times then it will get stuck on your mind and easier to write and explain. At the end of this lecture, you will be able to write Euclid's algorithm and be able to explain if someone asks you this question.

Module 5: Algorithms

Lecture 27 Linear Search - How it works?

In this video, you will learn Linear Search algorithm.

Lecture 28 Linear Search Coding

This lecture will teach you how to code a Linear Search. You will understand how it works and we will code it from scratch.

Lecture 29 Unit Testing Linear Search with JUNIT

In this video, we will create a unit test for the Linear Search algorithm. We will test the code that we just wrote on the previous lecture. I will also exhaust a little bit about JUNIT debugging and explaining in detail how you run multiple unit test at once and check which tests worked and which tests failed.

Lecture 30 Insert Sort - How it works?

After this class, you will understand how Insert Sort algorithm works.

Lecture 31 Insert Sort Coding

After this lecture, you will be able to understand and code an Insert Sort algorithm.

Lecture 32 Unit Testing Insert Sort with JUNIT

After this lecture, you will test and play with the results of the InsertSort class that we created on the lecture 9. We will use a new Assertion to test the arrays. We will also use a toString from the java.util.Arrays class to help us illustrate what our code is doing.

Lecture 33 Binary Search - How it Works?

After this lecture, you will understand what is Binary Search Algorithm and how it works.

Lecture 34 Binary Search Coding

In this lecture, you will learn how to code a Binary Search Algorithm. This will be coded using a non recursive way and after unit testing we will code using recursion.

Lecture 35 Unit Testing Binary Search with JUNIT

In this lecture, we will unit test our Binary Search Algorithm coded on the previous lecture. We will also add some code to demonstrate what the code is doing and how many iterations are happening for the search to be completed.

Lecture 36 Binary Search using recursion

In this lecture, you will learn how to code the Binary Search Algorithm using recursion. We will also explore the differences between the two classes (non using recursion and using it)

Lecture 37 Unit Testing Binary Search using recursion

In this lecture, we will test the Binary Search Algorithm written using recursion. More important we will quickly debug and show the recursive calls happening.

Lecture 38 Quick Sort - How it Works?

After this lecture, you will understand what is Quick Sort Algorithm and how it works.

Lecture 39 Quick Sort Coding

In this lecture, you will learn how to code a Quick Sort Algorithm. It will be coded using recursion. Each functionality will be explained and we will go through some more detail over the next lecture while unit testing.

Lecture 40 Unit Testing Quick Sort with JUNIT

In this lecture, we will test the Quick Sort Algorithm written using recursion. We will quickly debug the code to understand a little better.

Module 6: Data Structure

Lecture 41 Binary Tree - How it Works?

After this lecture, you will have a clear understanding of what is a Binary Tree and how it works.

Lecture 42 Binary Tree Coding

In this lecture, you will learn how to code a BinaryTree. We will also implement pre and post order traversal of the tree to print the elements in sort ordered or reverse ordered. We will use recursion. At the end you will understand what it is and how to code it.

Lecture 43 Unit Testing Binary Tree with JUNIT

In this lecture, we will test the BinaryTree coded using recursion. We will quickly debug the code to understand a little better. We will also use the library from Apache common lang to use ArrayUtils

Lecture 44 Linked List - How it Works?

After this lecture, you will understand what is a Linked List and how it works.

Lecture 45 Linked List Coding

In this lecture, you will learn how to implement a LinkedList.

Lecture 46 Unit Testing Linked List with JUNIT

In this lecture, we will test the LinkedList created on the previous lecture. We will also debug to have a better understanding of the code.

Lecture 47 Doubly Linked List - How it Works?

After this lecture, you will understand what is a DoublyLinkedList and what is the difference between DoublyLinkedList and LinkedList and you will also be able to understand how it works.

Lecture 48 Doubly Linked List Coding part 1 of 2

In this lecture, you will code and understand line by line what happens on this implementation of the DoublyLinkedList.

Lecture 49 Doubly Linked List Coding part 2 of 2

We will develop the remove method and as an nice extra we will override the toString method to get a nice String when we print our DoublyLinkedList

Lecture 50 Unit Testing Doubly Linked List with JUNIT

In this lecture, we will unit test our DoublyLinkedList methods add and remove. We will also see the result expected by the toString that we implemented.

Lecture 51 Prefix Tree - How it Works?

After this lecture, you will understand what is a Prefix or Trie Tree and you will also be able to understand how it works.

Lecture 52 Prefix Tree Coding part 1 of 2

In this lecture, you will learn how to code a Prefix or Trie Tree and we will implement the insert method which will break a String into the nodes of the tree. The search method will be implemented on the next lecture so you can have some time do drink some water.

Lecture 53 Prefix Tree Coding part 2 of 2

In this lecture, you will learn how to implement the search method of a Prefix or Trie Tree

Lecture 54 Unit Testing Prefix Tree with JUNIT part 1 of 2

In this lecture, we will test the Prefix or Trie Tree implemented on the last two lectures. We will also debug the insert method so you have a better understanding of what it is doing and how it is actually working. I broke the test in two parts to make is easier to understand.

Lecture 55 Unit Testing Prefix Tree with JUNIT part 2 of 2

In this lecture, we will test the Prefix or Trie implemented on the lectures 30th and 31st and we will also debug the search method so you have a good understanding of what it is doing and how it is actually working.

Lecture 56 Stack - How it Works?

In this lecture, you will understand what is a Stack and how it works.

Lecture 57 Stack Coding

In this lecture, you will learn how to implement a Stack and this implementation will be using Object as the object being stored. In the next lecture, we will refactor this code to implement generics.

Lecture 58 Unit Testing Stack with JUNIT

In this lecture, we will test the Stack implemented on the previous lecture and we will also debug so you have a better understanding of what it is doing and how it is actually working. A refactor using Generics will be done on the next lecture.

Lecture 59 Stack Coding with Generics

In this lecture, we will refactor the stack developed on the previous lecture and refactor to implement generics

Lecture 60 Unit Testing Stack Generics with JUNIT

In this lecture, we will test the Stack with Generics implemented on the previous lecture and we will also debug so you have a better understanding of what it is doing and how it is actually working.

Module 7: Interview Coding Questions

Lecture 61 Print odd numbers

In this lecture, we will code the interview question to print the odd numbers. We will also implement a second way to the problem.

Lecture 62 Unit testing Print odd Number with JUNIT

In this lecture, we will unit test the print odd numbers interview question. We will also debug and do a small refactor to make it fancier and cleaner.

Lecture 63 Longest substring without repeating character Introduction (Amazon question)

In this lecture, you will understand what is this question all about and how we are going to proceed to implement it on the next lecture.

Lecture 64 Longest Substring without repeating character Coding 1 of 2

In this lecture, we will implement this interview question that returns the number of characters and comment through the code.

Lecture 65 Longest Substring without repeating character Coding 2 of 2

In this lecture, we will refactor the code implemented on the previous lecture to also make available the sequence of characters and not just the count. We will also comment as we code for you to have a better understanding.

Lecture 66 Unit testing Longest substring without repeating character with JUNIT

In this lecture, we will unit test our interview exercise find the longest substring without repeating characters. We will also debug the code to get it in a bit more detail

Lecture 67 Sudoku Introduction (Amazon Question)

In this lecture, you will understand what is this question all about and how we are going to proceed to implement it on the next lecture.

Lecture 68 Sudoku coding part 1 of 3

Sudoku was broken in two coding parts to make it easier for you. In this lecture, we will implement the first part of the Sudoku interview question and comment through the code.

Lecture 69 Sudoku coding part 2 of 3

In this lecture, we will implement the second part of the Sudoku interview question and comment through the code. We will implement all the methods necessary to have the solve method working properly.

Lecture 70 Sudoku coding part 3 of 3 Unit Testing Methods

In this lecture, we will create unit test for all the methods that we developed to have the Sudoku working. We will test solve and printMe on the next lecture.

Lecture 71 Unit Testing Sudoku with JUNIT

In this lecture, we will test the solve method, debug through the code and check the output using the printMe method implemented.

350