Learn Java Se 8 And Prepare For The Java Associate Exam

Section Overview Preview 00:25

Overview of "Getting Started with Java."

The Features of the Java Programming Language Preview 04:43

The feature goals that the creators of Java had in mind when they were designing the language.  Learn about "platform independence" and other features.

The Java Platform Preview 05:49

Discover the "Java Runtime Environment (JRE)" and how it is used to execute Java programs.

The Java Platform

Test your knowledge of concepts on the Java Platform.

Editions and Versions Preview 08:43

The Java platform comes in many different configurations.  This lecture examines the different editions and versions that are available to us.

The Java Development Kit (JDK) Preview 03:39

The JDK is the complete Java platform - it includes all of the tools that are needed to write and run Java programs.

Your First Java Program - Part 1 (Code) Preview 13:00

A "50,000 feet view" of a small Java program.  Learn about classes, methods, parameters/arguments, return types, and modifiers.  We also cover the "front door" of a Java application: the "main" method.

Java Class and the "main" Method

Your First Java Program - Part 2 (Compilation and Execution) Preview 04:54

Now that the program has been written, how do we run it?  This lecture covers the compilation and execution process of a Java program.

Hello World Lab & Lab Files Preview 02:45

Your first coding exercise!  Instructions on how all of the labs are handled in the course, along with information on how to use TextEdit (Mac) and Notepad (Windows) for writing a Java program.  Average completion time: 30 minutes.

Java API Documentation (Javadocs) Preview 03:08

A Javadoc is an HTML site that contains documentation for a Java API.  This lecture shows you where you can find the Java SE 8 javadoc, and how to use it.

Section Overview Preview 00:22

Object Oriented Programming (OOP) Preview 06:02

Learn what an "object oriented program" is, and the benefits they deliver.

Objects vs. Primitives Preview 11:18

Discussion on the different characteristics between Java primitives (such as an int or boolean) and objects.

Objects vs. Primitives Addendum Preview 00:21

Stack & Heap Preview 02:56

One of the main keys to mastering Java is to understand how objects and method variables are represented in memory.  This lecture defines two areas of memory: the stack and the heap.

Using Objects Preview 15:00

Objects may contain state and/or behavior.  This lectures defines how to access and set these features of an object.

Q & A: "Member" Preview 00:14

Initializing Data Preview 06:35

Introduces the "constructor" as a means to initialize the state of an object.

Creating Object Types - Part 1 Preview 03:56

This lecture formally defines the purpose of a Class.

Working with the Car Type

Creating Object Types - Part 2 Preview 07:18

A walkthrough of creating a "Car" class with state and behavior.

Creating Object Types - Part 3 Preview 06:06

Now that the "car" class has been created, we'll look at how we can use it.  In addition, the "return" feature is demonstrated.

A note on "void" Preview 00:21

Building Constructors Preview 07:24

In a previous lecture, using a constructor to initialize an object was demonstrated.  Now you'll learn how to create your own constructors.

Constructors and Default Values

Test your knowledge on defining/invoking constructors and default values.

Default Constructor Preview 04:14

If you don't create a custom constructor, the compiler provides one for you.  Learn about the benefits and possible consequences of this feature.

Q & A: Default vs. "No-Arg" Constructor Preview 00:12

Initialization Blocks Preview 06:08

Constructors aren't the only way to initialize an object.  This lecture introduces another construct for this purpose: the initialization block.

Introduction to Objects Lab Preview 01:02

Instructions for the Objects lab.  Average completion time: 30 minutes.

Section Overview Preview 00:17

Static Variables Preview 09:59

Variables can be assigned to a class (rather than an object).  This lecture introduces the syntax of these variables and how they are used.

Static Methods Preview 08:31

Just like variables, methods may also be assigned to a class (rather than an object).  The syntax and restrictions that are placed upon these methods are demonstrated.

Static Reference Variables and null Preview 00:48

Using Static Variables and Methods

Test yourself to see how much you've learned about static variables and methods!

Static Initialization Block Preview 03:49

An instance initialization block is executed every time a new instance is created.  A static initialization block is only executed once: when the class is loaded.  Learn the syntax and restrictions of this feature.

What's the Value?

Let's see if you've mastered the order of initialization blocks and variables, upon object instantiation!

Quiz Explanation & Note About the Next Lecture Preview 01:34

"this" - Part 1 Preview 08:07

The keyword "this" refers to the specific instance of a class that is in focus.  Here we show how the keyword can be applied to class.

"this" - Part 2 Preview 06:59

Now that we know how "this" is applied, let's look at one of the main use cases of why it exists: disambiguation.  In addition we revisit and expand upon the topic of the stack and heap.

"this" - Part 3 Preview 06:10

The keyword "this" can also be used to chain constructors together.  Learn how to use this feature and the reasons why it exists.

Scope - Part 1 Preview 06:11

Scope defines the lifecycle and accessibility of state.  Learn how to recognize the scope of a variable in a class.

Scope - Part 2 Preview 07:57

More demonstrations on how to recognize the scope of a variable.

Garbage Collection Preview 05:53

In other programming languages, memory must be managed by the developer.  Java, helps us out here with a feature called "Garbage Collection."

Java Memory Leaks Preview 03:38

Although Java helps us out with memory management, we can still, unintentionally cause issues.  This lecture demonstrates a situation that could cause something similar to a memory leak (memory that is occupied but unused).

Static Lab Preview 00:38

Instructions for the Static lab.  Average completion time is 45 minutes.

Section Overview Preview 00:16

Packages Preview 15:08

Learn how to organize your code and prevent name collisions (two or more libraries that have a class with the same name), with "packages."

Packages and Imports

Do you know all of the rules of packages and imports?  Let's find out!

Classpath Preview 05:03

A classpath defines where classes can be found for compilation and execution.  Learn how to set these locations in this lecture.

More on Classpath Preview 01:06

JARs Preview 06:40

Most applications and libraries are distributed in compressed files called JARs.  Learn how to create these files.

Packages Lab Preview 00:33

Instructions for the Packages lab.  Average completion time is 20 minutes.

Section Overview Preview 00:32

Coding Standards Preview 08:36

Learn the conventions that most Java developers use when writing applications.

Comments Preview 03:03

Comments are blocks of text in code that are intended for other developers.  Anything that uses the comment syntax is excluded from normal code execution.

Javadoc Preview 05:40

In a previous lecture we talked about how to read Javadocs - in this lecture you'll learn how to write your own!

Identifiers and Comments

Have you memorized all of the rules about identifiers and comments?  Let's find out!

Primitive Data Types Preview 07:52

We've briefly mentioned primitives in previous lectures... now we'll dive into their syntax and usage.

Primitive Literals Preview 05:07

When a value is assigned to a primitive variable, the specific syntax used will determine their type.  Learn these rules in this lecture.

Primitive Conversion Preview 09:17

Sometimes we need to assign one primitive value type to a different variable type (such as when we pass an existing value as an argument to a method).  Learn those rules, including the concept of "casting" in this lecture.

Primitives

Test your knowledge on primitives and the rules of casting!

Big Numbers Preview 03:33

What happens when we need to use longer or more precise number than those supported by primitives?  Luckily we have BigInteger and BigDecimal two classes that support big numbers.

Primitives Lab Preview 00:29

Instructions for the primitives lab.  Average completion time is 30 minutes.

Section Overview Preview 00:20

Condtionals - If / Else If / Else Preview 07:56

Conditionals allow us to write blocks of code that are executed if a certain state is true or false

More on If/Else If/Else Statements Preview 01:34

Conditionals - Switch Preview 06:18

A switch is another syntax available when defining conditionals.

More on Switch Preview 01:26

Operators: Part 1 Preview 11:17

Learn the different operators available to Java, and just as important (especially for the exam) - the order of precedence.

Operators: Part 2 Preview 05:27

Concluding the post/pre-increment operator and a discussion on the ternary operator.

More Operator Examples Preview 01:16

Loops Preview 07:35

Conditionals are one type of control structure.  Another type allows us to continuously execute a block of a code while a condition is true.

Break, Continue, and Labels Preview 07:15

Loops allow us to manage their flow within their own bodies.  This lecture defines the keywords that allow us to manipulate that flow.

Enumerations (enum) Preview 08:22

An Enum (short for enumeration) allows us to create strongly typed (a structure that is verified by the compiler) label.  Learn the syntax of an enum in this lecture.

Java Syntax Lab Preview 00:42

Instructions for the Syntax lab.  Average completion time is 1 hour.

Section Overview Preview 00:18

String Objects Preview 06:02

A String is an object provided by the Java SE API, that exhibits some unique characteristics.  This lecture details the structure of this object.

String Operations and Operators Preview 05:26

Learn the most common methods and operations available to Strings.

Immutable Strings Preview 06:55

Once a String has been created it can never be changed.  This is known as "immutability."  Here you'll learn why Strings are immutable and how we handle this restriction in our programs.

Concatenation Operator Preview 00:19

Working with Strings

Test your knowledge on Strings!

Pass By Value: Primitives Preview 08:14

When a variable is passed as an argument into a method, what is really being passed?  This lecture details how primitive arguments are handled in Java.

Passing By Value: Objects Preview 04:55

Continuing the examination of passing arguments, with objects, including Strings.

Passing By Value Lab Preview 00:41

Instructions for the Passing by Value lab.  Average completion time is 30 minutes.

Section Overview Preview 00:21

Encapsulation and Data Hiding Preview 07:41

Encapsulation is one of the pillars of Object Oriented programming, and helps us design flexible and robust programs.

Getters and Setters: Part 1 Preview 06:26

Getter and setters are a strategy and convention for applying encapsulation.

Getters and Setters: Part 2 Preview 03:22

Now that encapsulation has been applied, the benefits are demonstrated.

Access Modifiers Preview 07:02

Learn how to apply restricted access to state and behavior to provide encapsulation.

Encapsulation

Test your knowledge on Encapsulation!

Encapsulation Lab Preview 00:33

Instructions for the Encapsulation lab.  Average completion time is 1 hour.

Section Overview Preview 00:19

Inheritance: Part 1 Preview 03:34

The next pillar of object oriented programming is "inheritance."  This is a feature that lets us build new objects from others they are related to.

Inheritance: Part 2 Preview 06:57

More demonstrations of how inheritance is applied and the rules that accompany this feature.

Chaining Constructors Preview 11:30

In a previous lecture, the concept of chaining constructors with the keyword "this" was demonstrated.  In this lecture, the focus is on chaining constructors between super and subtypes.

More On "Protected" Preview 01:30

Super and the First Statement Rule Preview 00:25

Overloading Methods Preview 07:00

All methods must have unique signatures.  However, as long as the parameter list is unique, multiple methods may have the same name.  This is called "overloading" a method.

Overriding Methods Preview 08:17

To change the behavior that is defined in a super class, we "override" methods.  This syntax and its restrictions are detailed in this lecture.

Covariant Returns Preview 01:30

When overriding a method, Java allows the return type to be a subtype of the type declared in the overridden method.  This feature is known as a "covariant return."

The Three Faces of Final Preview 05:30

The keyword "final" may be applied to variables, methods, and classes.  This feature prevents further modification of these constructs, once defined.

Revisiting the Switch Statement Preview 00:40

Know This For The Exam: Class/Object Invocation Order Preview 02:32

Inheritance Lab Preview 00:41

Instructions for the Inheritance lab.  Average completion time is 1 hour.

Section Overview Preview 00:25

Polymorphism Demo Preview 08:00

Polymorphism (the ability to send the same general message to related types, but have them process the message in a unique manner), is a tough subject.  To help mitigate the difficulty in learning this, we start with a demo.

Polymorphism: Part 1 Preview 07:17

The first steps at understanding the syntax of polymorphism.

Polymorphism: Part 2 Preview 07:02

More examples and discussion on polymorphism.

Being Available vs. Being Inside Preview 00:42

Benefits of Polymorphism Preview 08:19

See how polymorphism enables us to write flexible and dynamic applications.

Object Type Casting Preview 06:13

Casting changes the reference to a more specific type (allowing for additional state and behavior to be accessed).

The Object Class Preview 11:39

At the top of every object hierarchy is java.lang.Object.  Learn about overriding Object's toString, equals, and hashCode methods.

Polymorphism Lab Preview 00:36

Instructions for the Polymorphism lab.  Average completion time is 45 minutes.

Section Overview Preview 00:23

Abstract Classes: Part 1 Preview 07:18

Abstract classes are constructs that allow subtypes to share common state and behavior definitions, all while enabling polymorphism.

Abstract Classes: Part 2 Preview 05:17

More examples of using abstract classes.

Abstract Methods: Modifiers & Inheritance Preview 01:20

Interfaces: Part 1 Preview 06:16

Interfaces define a role that a class can fulfill.  Like abstract classes, an interface enables objects to be treated polymorphically.

Interfaces: Part 2 Preview 11:22

Examples of using interfaces for polymorphism and demonstrations of new interface features that were added to Java SE 8.

Interfaces: Part 3 Preview 06:26

A discussion about the benefits of using interfaces.

Remember: All Interface Methods are "public." Preview 00:24

Abstract Classes and Interfaces Lab Preview 00:55

Instructions for the Abstract Classes and Interfaces lab.  Average completion time is 45 minutes.

Section Overview Preview 00:18

Marker and Functional Interfaces Preview 03:43

A marker interface has no methods, and a functional interface has only one abstract method.  The latter is used with lambda expressions.

Lambda Expressions Preview 07:21

A lambda expression allows us to use a terse syntax to define the implementation of a functional interface.

Predicate Preview 02:31

A predicate is a general functional interface that is provided by the Java SE API.

Static Imports Preview 05:06

Static Imports allow us to code static references from other types, as if they were defined in our own class.

Lambda Expressions Lab Preview 00:29

Instructions for the Lambda Expressions lab.  Average completion time is 30 minutes.

Section Overview Preview 00:20

LocalDate Preview 08:03

Java SE 8 includes a new java.time package.  LocalDate is an immutable class to represent a date (no timestamp).

LocalTime, LocalDateTime, and Period Preview 08:48

A look at three other immutable java.time types.

DateTimeFormatter Preview 08:14

Dates and Times may be formatted in a custom manner, through the use of the DateTimeFormatter.

Dates and Time Lab Preview 00:44

Instructions for the Dates and Time Lab.  Average completion time is 30 minutes.

Section Overview Preview 00:29

Arrays Preview 11:15

An array is a data structure that holds multiple primitives or objects that are of the same polymorphic type.

Polymorphism Revisited Preview 06:49

An example of how polymorphism may be applied to an array.

Multi-Dimensional Arrays Preview 04:14

A multi-dimensional array holds one or more arrays.

More on multi-dimensional arrays Preview 00:59

Sorting and Searching Arrays Preview 03:27

Helper methods to sort and search through an array.

Common Array Mistakes Preview 03:09

Avoid these common beginner mistakes!

Varargs Preview 03:00

Varargs allows methods to take zero or more objects (without having to explicitly wrap them in an array).

Arrays Lab Preview 00:21

Instructions for the Arrays lab.  Average completion time is 30 minutes.

Section Overview Preview 00:22

When Arrays Are Not Enough Preview 03:36

Outlines the differences between arrays and collections.

Collections Preview 05:04

The basic syntax of using a collection.

The Collection Interface Preview 02:51

The most general interface that can be used with many collection classes (excluding maps).

Iterator Preview 03:45

An iterator provides a polymorphic way of looping through a collection.

Lists Preview 04:08

A list is a collection that retains the order the objects were added to it (unless it is sorted).  In addition it permits duplicate objects.

Lists

Test your knowledge on java.util.List implementations!

Sets Preview 03:33

A set is a collection that organizes the data in a order for fast searching (so it doesn't necessarily maintain the order that you put them in).  In addition, it does not allow duplicate (equal) objects.

Sets

Test your knowledge of Sets!

Queues Preview 05:42

A queue is a FIFO collection (first in, first out).  Items are added to the tail and removed from the head.

Deques Preview 03:30

A deque is a "double ended queue," which allows FIFO (first in, first out) and LIFO (last in, first out) access.  Objects can be added and removed from either the head or the tail.

Maps Preview 07:28

A map is a collection that is great for random access.  Each item in a map is associated with a unique object based key.

Collections Lab Preview 00:44

Instructions for the Collections lab.  Average completion time is 30 minutes.

Section Overview Preview 00:11

Limitations of Collections Preview 05:20

Collections are unable to store primitives.  However, the Java SE API provides "wrapper" classes which enable primitive values to be added to a collection. 

Revisiting Overloading Methods: Order of Precedence Preview 01:48

Generics and Autoboxing Preview 05:46

Generics and autoboxing help simplify some of the limitations outlined earlier in this section.

Diamond Operator Preview 02:04

Java SE 7 introduced the diamond operator <> to simplify declaring parameter types.

Building a list from Arrays.asList and Anonymous Arrays Preview 00:50

Sorting and Searching Collections Preview 01:31

Like arrays, collections can be sorted and searched through, with methods provided by the Collections class.

Comparable Preview 04:16

In order for a type to be sortable, it must provide information on how it should be sorted (when compared to another object).  Implementing the Comparable interface is one option for providing this information.

Comparator Preview 03:17

Another option for providing sorting information is to create a Comparator object which takes two objects and returns their order.

Type Parameters and Comparable/Comparator Preview 00:43

More With Collections Lab Preview 00:31

Instructions for the More With Collections lab.  Average completion time is 30 minutes.

Section Overview Preview 00:20

Throwable Preview 02:49

A Throwable is an object that contains error or exception information.

Catching Exceptions Preview 05:43

Once a Throwable is thrown, the JVM looks for code to handle the exception.  This process is known as "catching an exception."

Finally Block Preview 04:14

Finally is an optional part of a try/catch block, which ensures that code will be run in any circumstance (other than when a catastrophic error occurs).

The Exception Object Preview 01:46

Exception is a subtype of Throwable, with methods for learning about what went wrong during the execution of a program.

Unchecked (Runtime) vs. Checked Exceptions Preview 04:36

The compiler will enforce developers to write code that handles certain types of exceptions.  These are known as "checked" exceptions.  Others, which are not enforced, are known as "unchecked" or "runtime" exceptions.

Creating Exceptions Preview 02:17

Learn how to create and throw custom exceptions in your applications.

Exception Handling Lab Preview 00:23

Instructions for the Exception Handling lab.  Average completion time is 20 minutes.