Overview of "Getting Started with Java."

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

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

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

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

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.

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

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.

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.

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

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

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.

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

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

This lecture formally defines the purpose of a Class.

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

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

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

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

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

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

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

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.

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.

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.

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.

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

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

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

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

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).

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

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

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

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

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

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

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.

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

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

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

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.

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.

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

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

A switch is another syntax available when defining conditionals.

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

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

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

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

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.

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

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

Learn the most common methods and operations available to Strings.

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.

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.

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

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

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

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

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

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

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

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.

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

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.

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.

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

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 keyword "final" may be applied to variables, methods, and classes.  This feature prevents further modification of these constructs, once defined.

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