Now we'll pull together everything we've learned so far and use our new skills to start solving real problems. Or, put another way, we'll start designing algorithms.

algorithms1

Algorithms I

Our next lesson starts the third half of the class, our exploration of data structures, algorithms, and algorithm analysis.

algorithmsandlists

Algorithms and Lists

This lesson is on algorithms and strings, and gives us a bit more practice with both.

algorithmsandstrings

Algorithms and Strings

Let's dive in to the world of anonymous classes.

anonymousclasses

Anonymous Classes

Let's learn about our first data structure: arrays, which put data values in order.

arrays

Arrays

Let's apply some of the same ideas we've developing sorting to a new problem, search.

binarysearch

Binary Search

Next we'll begin learning how to work with exceptions by understanding how to handle them when they occur.

catchingexceptions

Catching Exceptions

Let's explore a bit of programming internals, specifically your code is tranformed before it is executed in a process known as compilation.

compilation

Compilation and Type Inference

Next we'll examine how to make our conditional statements a bit more complex, allowing us to make more interesting decisions based on data in our programs.

compoundconditionals

Compound Conditionals

Our next lesson examines what happens when objects are created.

constructors

Constructors

This lesson puts our new abilities with objects to use modeling a real-world system.

datamodeling1

Data Modeling 1

Next we'll complete another data modeling exercise that pulls together everything that we've learned.

datamodeling2

Data Modeling 2

Let's examine errors, debugging, and maintaining a healthy mindset as you learn to work with computers.

debugging

Errors and Debugging

Creating a completely independent copy of an object is surprisingly challenging.

deep_copies

Deep Copies

Next we'll investigate how to enable encapsulation through visibility modifiers and setters and getters.

encapsulation

Encapsulation

What does it mean for two objects to be equal? And how do we copy them? In this lesson we'll find out.

equality

Equality and Object Copying

As we begin writing algorithms, let's stop and discuss how to organize our code into reusable units called functions.

functions

Functions

In this lesson we'll explore the connections between functions and algorithms.

functionsandalgorithms

Functions and Algorithms

Next we introduce a language feature that allows us to write both general and type-safe code.

generics

Generics

Let's continue our exploration of graphs by exploring algorithms that operate on them.

graphalgorithms

Graph Algorithms

In this lesson we'll introduce graphs, another commonly-used data structure and another great way to practice with recursion.

graphs

Graphs

This lesson explores hashing, a mysterious and yet incredibly useful idea that is even included directly in our programming language!

hashing

Hashing

Welcome to learncs.online! We're excited to join you as you start your journey in computer science and programming. Today!

helloworld

Hello, world!

This lesson is short and fun. Let's combine what we know about hashing, arrays, and linked lists to implement our own map.

implementingamap

Implementing a Map

Next we'll examine how to implement interfaces on our own classes.

implementinginterfaces

Implementing Interfaces

This lesson may be the most important of the entire course, since it shows you how to use other people's code!

imports

Imports and Libraries

Our next lesson explores the relationships between classes established through inheritance.

inheritance

Inheritance

Iterators enable use of the enhanced for loop to iterate through a collection of data.

iterators

Iterating Over Data Structures

A graphical user interface is pretty useless if it can't respond to user interactions. Here we will see how event-driven programming allows us to respond to the user.

javafxeventdriven

Event Driven Programming

FXML allows us to describe our GUI declaratively.

javafxfxml

FXML - FX Markup Language

We can create graphical user interfaces with JavaFX framework.

javafxoverview

JavaFX

Conditionals control what parts of a program get executed. Learn about Java's ternary operator and `switch` statements and expressions.

kotlin_to_java_conditionals

Conditionals

All Java code and variables must be inside a class. In this lesson, you will learn how to create Java classes.

kotlin_to_java_creating_classes

Creating Classes

It's time to write our first Java program. The snippets you saw in the  introductory lesson weren't programs. In this lesson, you'll learn to make a  program from a class and a `main()` function.

kotlin_to_java_hello

Hello, Java!

Welcome to Kotlin to Java! This is a bridge from Fundies 1 to Fundies 2 especially (but not exclusively) for those of you who are new to Java.

kotlin_to_java_intro

Introduction

Classes are central to Java. Learn how to construct objects and when to use primitive types or their wrapper classes.

kotlin_to_java_using_classes

Using Classes

This lesson explores lambda expressions, a terse way of implementing interfaces using anonymous classes.

lambdaexpressions

Lambda Expressions

Now for a different take on lists, we'll examine lists that store the position of items using reference linking.

linkedlists

Linked Lists

This lesson continues discussing linked lists and implement a few list methods together.

listreview

Lists Review and Performance

Next we'll learn how to use lists, a linear data structure but one that is a bit more useful than the arrays that we've been working with so far.

lists

Lists and Type Parameters

This lesson covers our last core computer capability: the ability to repeat something multiple times, very quickly.

loops

Loops

Let's look at two more very useful collections: maps and sets.

mapsandsets

Maps and Sets

We'll continue in this lesson by examining Merge Sort, an interesting and efficient sorting algorithm.

mergesort

Merge Sort

Next we'll continue discussing functions and introduce several common algorithm patterns.

morefunctions

More About Functions

Our next lesson expands our ability to work with sequential data into multiple dimensions!

multidimensionalarrays

Multidimensional Arrays

How many problems can nothing cause? Quite a few! We'll learn more about the nothing that is a huge problem in this lesson.

null

objects1

Introduction to Objects

Let's continue our discussion of objects by examining object methods.

objects2

Objects, Continued

This lesson introduces a big new word and a big new idea: polymorphism.

polymorphism

Polymorphism

Let's get a bit more practice with collections, those basic data structures that are so useful.

practicewithcollections

Practice with Collections

Let's pause for a bit more practice with functions before we continue our journey together.

practicewithfunctions

Practice with Functions

This lesson continues our practice with interfaces.

practicewithinterfaces

Practice with Interfaces

Let's pause for more practice with loops and algorithms, including several chances to get practice solving real problems.

practicewithloops

Practice with Loops and Algorithms

Let's get some additional practice with trees and recursion!

practicewithrecursion

Practice with Recursion

Let's reinforce what we know about strings by working with a few more problems together!

practicewithstrings

Practice with Strings

Simple data structure that limits access to data using a FIFO (first in first out) constraint.

queues

Queues

Next we'll continue on to examine Quicksort, a new sorting algorithm with some very interesting characteristics. Then we'll review the sorting algorithms that we've learned together.

quicksort

Quicksort

This lesson introduces recursion, a powerful new problem-solving strategy.

recursion

Recursion

Our focus in this lesson is on references, both generally and specifically.

references

References

Let's combine what we know about polymorphism and references to deepen our understanding even further.

referencesandpolymorphism

References and Polymorphism

The Set interface is a collection of unique items. The Map provides a Set of keys where each key is associated with (or mapped to) a value.

setsandmaps

Sets and Maps

One of the things that makes computers so powerful is their ability to make decisions. We'll explore that capability in our programs in this lesson.

simpleconditionals

Conditional Expressions and Statements

This lesson begins our examination of sorting algorithms, which represent both a conceptual and an implementation challenge.

sorting

Sorting Algorithms

Simple data structure that limits access to data using a LIFO (last in first out) constraint.

stacks

Stacks

Next we'll continue understanding Java objects by exploring the static keyword and its implications.

static

Static

This lesson explores streams, an advanced programming pattern useful for performing transformations on data.

streams

Streams

Let's meet a new type of data and our first example of an object.

strings

Strings

Let's continue to learn about exceptions by finding out how and when to generate our own errors.