Introduction to Java (Latte)

In this lesson, students learn more about Karel and Karel’s world. Students learn about walls in Karel’s world, the directions Karel can face, and how to identify a location in Karel’s world using streets and avenues. In these exercises, students will begin to see the limitations of Karel’s commands. Students will need to apply Karel’s limited set of commands to new situations. For example, how can they make Karel turn right, even though Karel does not know a turnRight command?

This lesson discusses printing a message in Java. Instead of extending Karel, students will now extend Console Program to print to the Console.

public class Welcome extends ConsoleProgram
{
    public void run()
    {
      System.out.println("*insert message here* "); 
      System.out.println("*insert message here* "); 
    } 
}

Variables allow us to store information such as numbers, words, or true/false expressions. A variable can be thought of as a box that stores information inside. In Java, variables are composed of three things: a name, type, and value.

In this lesson, students will learn how to retrieve user input by various methods including readLine, readInt, readDouble, and readBoolean. This will allow them to take in data from the user to make our programs work for them.

Arithmetic Expressions allow us to perform mathematical operations within Java. Such expressions can be used for basic math and even more complex algorithms.

This lesson introduces the students to Casting, which is turning something of one type into another type.

How do we write code that tells us whether a user is logged in to our program? Booleans are the solution to these questions. A boolean refers to a value that is true or false. Those are the only values of a boolean expression, and these are useful if we want to check if something is true or false.

Logical operators allow us to connect or modify Boolean expressions. Three logical operators are the !, ||, && characters.
! = NOT
|| = OR
&& = AND
Logical operators can be used in combination.

With these logical operators, we can construct logical statements such as “I go to sleep when I am tired OR it’s after 9pm”, “I wear flip flops when I am outside AND it is NOT raining”

Comparison operators let us compare two values. Using comparison operators in programming is similar to math in that less than <, greater than >, less than or equal to <=, and greater than or equal to >= are the same. The differences are that operators for equal to are == and not equal are !=. Using comparison operators allows our program to make decisions.

This lesson explores for loops–why they are useful, and how to use them to repeat code a fixed number of times.

Just like in Karel, Java has while loops. While loops are a way to repeat a block of code so long as some condition remains true. The condition is written in the form of a boolean expression. As long as the boolean expression remains true, code within the while loop will be executed. The moment that the boolean expression becomes false, code outside of the while loop will be executed; the loop is done.

This lesson introduces If Statements. We use if statements to run a segment of code only if some boolean expression first evaluates to true.

Infinite loops can occur unintentionally if you are not careful with the conditions of a while loop. In these cases, the infinite loop can cause the program to crash. However, infinite loops can be a very useful tool in programming. If your program needs to repeat a block of code an indefinite number of times, an infinite loop may be the correct approach. Repeating code is helpful, but it’s just as important to be able to stop the loop so that the rest of the program can continue executing. Loops can be stopped using the break statement. When the loop encounters a break statement, it quits running the loop and program flow continues.

This lesson introduces Short-Circuit Evaluations. In a Short-Circuit Evaluation, if the result of a Boolean Expression can be determined by the first argument, the second argument is not evaluated.

De Morgan’s Laws are rules that show how we can negate “and”s and “or”s. Not (A and B) is the same as (not A) or (not B). Similarly, not (A or B) is the same as (not A) and (not B).

A String is a sequence of characters. We use Strings to represent full words and sentences. For example, the famous “Hello World” is a String. Some more examples of Strings:
“I am a String. A sequence of characters strung together to form words and/or sentences.”
“CodeHS is the best coding website ever! Everyone loves CodeHS!”
“She sells sea shells by the sea shore.”
“Strings!”
“abcdefghijklmnopqrstuvwxyz”
A String is not a primitive type like int, char, boolean, and double are. Primitive types always start with lowercase letters, but a String starts with a capital letter. This makes it an object.

This lesson is a summative assessment of the unit’s learning objectives.

In this lesson, we learn about methods in Java. Methods allow us to break down our code into reusable parts, avoid using repeated code, and simplify our code.

In this lesson, we continue to build our understanding of methods and introduced to parameters. Parameter are inputs to methods.

If methods are boxes, then parameters are inputs to our boxes (what goes inside the box).

Parameters allow us to generalize our methods so that they can solve more than one specific instance of a problem, and instead can solve different versions of the same problem (for example, add 10 to any given number).

Think of a method like assigning a task. A return value is giving you the completed work.
This allows you to write methods that do some work for you and send back the result.
Parameters are like inputs into the function, and the return value is output.

Comments are an important part of programming style. Programs are usually written by teams of people and maintained for many years. Others need to be able to read your code and understand what is going on.

This lesson introduces Javadocs, which are a standard, agreed upon way of commenting Java code. There is a tool, also called Javadoc, that is able to read Javadoc comments and create clean, clear documentation for your Java programs. Javadoc refers to both the tool and the style of commenting Java code.

From now on, we will be writing Javadoc comments in our programs.

Strings come prepackaged with several methods that we can use to help us do cool things! In this lesson we learn how to find and read documentation about how to use the String methods, and we’ll write several programs that call methods on Strings in order to get information about them and manipulate them to form new Strings.

In this lesson, we’ll examine the similarities and differences between the String class and the char primitive type. Strings are simply sequences of chars.

We also learn that all char values have a corresponding int value. chars are actually stored as numbers! For example, 65 corresponds to ‘A’, 66 corresponds to ‘B’, and so on. We’ll learn about special characters like tabs, quotes, and new lines, and how to store and print these special characters using escape sequences like ‘\n’

Lastly, we learn about the Character class. The Character class provides several useful methods that allow us to manipulate and get information about char values.

All programs have bugs at some point in the development process. Bugs are ok! They show us exactly where the problems are in our code and give us helpful information so that we can fix these problems.

When there is a bug in your program, Java will actually provide helpful information about where the bug is and what kind of bug is occurring by throwing an Exception. In this lesson we’ll learn about the different kinds of exceptions and what they mean. That way, when we try running our programs and see exceptions, we’ll know how to use that information to debug our programs!

We’ve learned about writing our own methods that take in parameters and return return values. We’ve learned about the relationship between Strings and characters. We’ve learned about using the methods of the String class and the Character class. We’ve learned about looping through the characters of a String using a for loop. It’s time to put that all together to write some methods that perform some advanced manipulation of Strings.

This lesson is a summative assessment of the unit’s learning objectives.

In this lesson students learn about classes and objects, the foundation of Object Oriented Programming. This lesson introduces a lot of new vocabulary, but it will be reinforced and used in concrete examples and exercises over the next several lessons.

Students have been creating objects of the String class, they just haven’t dove into that terminology yet. In this lesson, students will learn about objects, which are things that have state and behavior, and classes, which are the templates for creating objects. Students will be creating instances of objects in this lesson.

In this lesson, students will dive deeper into the relationship between classes, objects, and instances (generally instances and objects refer to the same thing). Students will get more practice identifying classes and objects, creating objects from classes, and calling methods on objects.

In this lesson, students learn about the overarching idea of “using a class as a client”. In Java, everything is represented as a class. Classes are a nice way of bundling up functionality. There are classes written for a lot of common needs (such as the String class and the Character class), and we can use these classes in our programs.

When someone else creates a class, and you use the functionality of that class, that is called being a client of the class. Users don’t need to know exactly how everything works inside the class, they can just use all the functionality of that class without worrying about the inner workings. For example, you can use the String class to create String objects, and call methods on the objects to get information like the length and the characters at certain indices, without ever looking at the source code for the String class.

Now that students have had practice using classes without actually changing the source code for a class, they dive in and actually start writing our own classes. In this lesson, students will learn the basics of writing classes including implementing constructors, using instance variables, and writing a toString method.

In this lesson, students will learn about instance methods and start adding more interesting instance methods to their classes. The instance variables define the state of an object (instance), and the instance methods define the behavior of an object (instance). Instance methods give the object new abilities, they define what the object can actually do.

toString is one example of an instance method, it returns the instance’s (object’s) instance variables put together as a String, that way the instance can be printed out to the screen. It gives an object the ability, or the behavior, to represent itself as a String. In this lesson, we’ll start adding more instance methods to our classes.

In this lesson students will learn about a special type of instance method: getter and setter methods. Getter and setter methods give the client access to the private instance variables in a class. Programmers don’t want to make instance variables public because then the client has full access to them, and might accidentally do something that messes them up (for example, it doesn’t make sense to have a negative width or a negative height for a Rectangle object). Instead, programmers expose limited access to them through getter and setter methods. That way, they can allow only certain changes to the instance variables, and block other changes.

In this lesson students learn about Class methods and Class variables, which are different from Instance methods and Instance variables.

Students have learned a lot about Instance methods and Instance variables. Each instance of a class has its own instance methods, and its own instance variables. For example, two different Rectangle objects can each have their own width and their own height. These values can be different from instance to instance.

The key difference with Class methods and Class variables is that all instances share the exact same Class methods and Class variables. Each instance does not get its own copy, it is all shared among instances. These methods and variables exist at the Class level, not the Instance level.

Class methods and Class variables are specified using the static keyword.

In this lesson students will learn about method overloading: writing several different methods, each with the same name. As long as each method’s parameter list is different, method can use the same name multiple times!

In this lesson students explore the scoping of a variable, which is where the variable is “defined” or where it exists. In this lesson getting students to define and explain the concept themselves is key.

In this lesson students learn several new vocabulary terms about Classes and Object Oriented Programming. There’s a lot of vocab in this lesson, but it’s all important for the AP exam. Many of these terms students have seen before, however this lesson will describe what they mean.

The most important term to learn is the this keyword. this is a reference to the current instance. this is used to avoid naming conflicts between instance variables and parameters.

In this lesson, students learn about the difference between primitive and object variable types. So far, students have used these different variable types, but have not explored the differences between the two.

This lesson looks at the differences between primitive and object types and discusses the implications of these differences.

In this lesson, students learn about class hierarchy and make subclasses and superclasses. Class hierarchy is a critical part of the Java language and used to help reuse code between classes.

Students will explore the relationships of classes in this lesson and then extend that to class design in the next lesson.

In this lesson, students learn about class structure and how we can further enhance that class structure with abstract classes. They will then use this knowledge to implement abstract classes.

Abstract classes are a key concept for polymorphism. In this lesson, students will get the knowledge of how to use abstract classes, but some of the reasons why we implement them will become more apparent in the next lesson.

In this lesson, students learn about polymorphism and how it applies to dynamic binding at run time. Students will also explore how polymorphism can be used as a formal parameter in methods or as a declaration type for arrays or ArrayLists.

In this lesson, students will learn about interfaces. Interfaces share a lot of similarities with abstract classes and part of this lesson will focus on comparing the two.

Students will make and implement their own interfaces as well as implementing interfaces that are created by Java.

This lesson is a summative assessment of the unit’s learning objectives.

In this lesson, students will learn about four types of Data Structures. An array is a list of fixed size. An array list is a list of changing size. A 2D-Array is a grid, table, or list of lists. A Hash Map is a Key-Value store.

In this lesson, students learn about arrays and make their first arrays. Arrays are one of the main data structures students will need to understand. This lesson introduces the idea, shows students how to create them, and explains how to access data elements to retrieve and update values.

In this lesson, students will learn how to traverse an array to access all of the array elements. They will then apply this to real-world activities.

Traversing through an array is a key skill for many programs and as a result, this topic is covered extensively on the AP test.

In this lesson, students will learn about ArrayLists and make their own ArrayLists. They will then learn basic methods for ArrayLists to traverse, add, and access the elements in the ArrayList.

While this lesson focuses on ArrayLists, students should be starting to think about how Arrays and ArrayLists are similar and different. This concept is key and will be further explored in the next lesson.

In the lesson, students will learn more about the differences between Arrays and ArrayLists and make an ArrayList like class using an Array.

Having learned two different data structures for storing lists, it is only natural to compare and contrast these two structures. Students should come into this lesson with a basic understanding of differences but will develop a deeper understanding through a series of examples and activities.

In this lesson, students will learn about the list interface and use this to implement generic formal parameters and create classes that use the List interface.

This lesson is not currently in scope for the AP test, but understanding how to implement and use Java interfaces is a key concept for object-oriented programming.

In this lesson, students will learn about 2D arrays. The will also first be exposed to the idea of a nested loop, which will be used to access all the elements in a 2D array.

2D arrays are a key idea for students to grasp. They should spend time to fully understand how the loops execute. They can further supplement these concepts through the Traversing 2D Arrays exercises in the Supplemental Material.

In this lesson, students will learn about HashMaps and use them to create solutions to real-world problems. HashMaps offer a different way of storing data in Java using a key/value pair. While this topic is out of scope for the AP test, it is a key data structure used in several programming languages and may make a good topic for after the AP test.

In this lesson, students learn how to convert from different number systems to decimal. They also learn more about why binary is used by computers and have an opportunity to write a code that will convert a binary number into a decimal number.

In this lesson, students learn about creating a large scale project using multiple classes. This lesson walks through the creation of a basic Blackjack game.

In this lesson, students will learn about 2D arrays and classes by creating a Battleship program. Through a series of lessons, the game will be broken down into pieces to help implement the solution.

This lesson is a summative assessment of the unit’s learning objectives.