Topics

Review

• Other ArrayList Methods
• The add(value) Method
• The add(index, value) Method
• The clear() Method
• The get(index) Method
• The remove(index) Method
• The set(index, value) Method
• The size() Method
• ArrayList Search Methods
• The contains(value) Method
• indexOf(value) Method
• lastIndexOf(value) Method
• Writing a Method to Read in Files
• Stopping Execution of a Loop
• The break Statement
• The continue Statement
• The switch Statement

New Material

• Writing Better Programs
• Object Oriented Programming
• Objects and Values
• Classes and Objects
• Point Objects
• Defining a Class
• Fields
• Defining a Point Class
• Adding Methods to Our Point Class

Homework 8

Homework 8 is due this Sunday at 11:59 PM.

You will find the assignment here.

If you have a problem or a question, make a post on the Class Discussion Area.

Tips and Examples

Review

Other ArrayList Methods

• ArrayLists have a number of useful methods
• Below is a table of methods and what they do

  Method	Description
  add(value)	Adds a value to the end of the list
  add(index, value)	Adds a value at a given position
  clear()	Removes all entries from the list
  get(index)	Returns the value at a given position
  remove(index)	Remove the element at a given position
  set(index, value)	Changes the value at a give position
  size()	Returns the number of elements in the list

The add(value) Method

• add(value) creates an element at the end of the list
• This operation is something you cannot do with an array

  import java.util.ArrayList;
  
  public class ListAdd {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          System.out.println(list.size());
          list.add("one");
          System.out.println(list.size());
          list.add("two");
          System.out.println(list.size());
          
          System.out.println(list.size());
          System.out.println(list);
      }
  }
  
  $ java ListAdd 
  0
  1
  2
  3
  [one, two, three]

The add(index, value) Method

• add(index, value) adds a value at a given index
• It moves the element already at that position, and all following, to the right

  import java.util.ArrayList;
  
  public class ListAddIndex {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          System.out.println(list);
          list.add(1, "one and a half");
          System.out.println(list);
      }
  }
  
  $ java ListAddIndex
  [one, two, three]
  [one, one and a half, two, three]

The clear() Method

• The clear() method removes all entries from a list
• This is also something that cannot be done with an array

  import java.util.ArrayList;
  
  public class ListClear {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          System.out.println(list);
          list.clear();
          System.out.println(list);
      }
  }
  
  $ java ListClear
  [one, two, three]
  []

The get(index) Method

• The get(index) method returns the value of the element at a given index
• It performs the same function as using square brackets [ ], with an array

  import java.util.ArrayList;
  
  public class ListGet {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          System.out.println(list);
          System.out.println("The value at index 1: " + list.get(1));
      }
  }
  
  $ java ListGet
  [one, two, three]
  The value at index 1: two

The remove(index) Method

• The remove(index) method delete an entry at a given index position
• Every element after the one removed is shifted one positon to the left
• Once again, this is an operation that cannot be performed on an array

  import java.util.ArrayList;
  
  public class ListRemove {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          System.out.println(list);
          list.remove(1);
          System.out.println(list);
      }
  }
  
  $ java ListRemove
  [one, two, three]
  [one, three]

The set(index, value) Method

• The set(index, value) method changes the value at a given position

  import java.util.ArrayList;
  
  public class ListSet {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          System.out.println(list);
          list.set(1, "2");
          System.out.println(list);
      }
  }
  
  $ java ListSet
  [one, two, three]
  [one, 2, three]

The size() Method

• The size() method returns the number of elements in a list
• It is equivalent the the length attribute of an array

  import java.util.ArrayList;
  
  public class ListSize {
      public static void main (String[] args){
          ArrayList<String> list = new ArrayList<>();
          list.add("one");
          System.out.println("Elements: " + list.size());
          list.add("two");
          System.out.println("Elements: " + list.size());
          list.add("three");
          System.out.println("Elements: " + list.size());
      }
  }
  
  $ java ListSize 
  Elements: 1
  Elements: 2
  Elements: 3

ArrayList Search Methods

• ArrayList provides methods that can be used to search the list

  Method	Description
  contains(value)	Returns true if the value can be found in the list
  indexOf(value)	Returns the index of the first occurence of a value in the list or -1 if the value cannot be found
  lastIndexOf(value)	Returns the index of the first occurence of a value in the list or -1 if the value cannot be found

The contains(value) Method

• contains(value) is a boolean method that returns true if the list contains the given value

  import java.util.ArrayList;
  
  public class ListContains {
      public static void main (String[] args){
          ArrayListt<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          System.out.println("\"two\" is in list: " + list.contains("two"));
          System.out.println("\"four\" is in list: " + list.contains("four"));
      }
  }
  
  $ java ListContains
  "two" is in list: true
  "four" is in list: false

indexOf(value) Method

• indexOf(value) returns the index of the first occurence of the value in the list
• If the value does not occur in the list it returns -1

  import java.util.ArrayList;
  
  public class ListIndexOf {
      public static void main (String[] args){
          ArrayList<String> teams = new ArrayList<>();
          teams.add("Red Sox");
          teams.add("Pats");
          teams.add("Celtics");
          teams.add("Bruins");
          teams.add("Red Sox");
          System.out.println(teams);
          System.out.println("Index of \"Red Sox\": " + teams.indexOf("Red Sox"));
          System.out.println("Index of \"Yankees\": " + teams.indexOf("Yankees"));
      }
  }
  
  java ListIndexOf
  [Red Sox, Pats, Celtics, Bruins, Red Sox]
  Index of "Red Sox": 0
  Index of "Yankees": -1

lastIndexOf(value) Method

• lastIndexOf(value) returns the index of the last occurence of the value in the list
• If the value does not occur in the list it returns -1

  import java.util.ArrayList;
  
  public class ListLastIndexOf {
      public static void main (String[] args){
          ArrayList<String> teams = new ArrayList<>();
          teams.add("Red Sox");
          teams.add("Pats");
          teams.add("Celtics");
          teams.add("Bruins");
          teams.add("Red Sox");
          System.out.println(teams);
          System.out.println("Last index of \"Red Sox\": " + teams.lastIndexOf("Red Sox"));
          System.out.println("Last index of \"Yankees\": " + teams.lastIndexOf("Yankees"));
      }
  }
  
  $ java ListLastIndexOf
  [Red Sox, Pats, Celtics, Bruins, Red Sox]
  Last index of "Red Sox": 4
  Last index of "Yankees": -1

Writing a Method to Read in Files

• Creating an ArrayList from the contents of a file is something we might want to do often
• Any job you might often want to do is something that should be turned into a method
• Here is an program that contains a method to create an ArrayList from a file

  import java.io.*;
  import java.util.*;
  
  public class FileToList {
      public static void main (String[] args) 
          throws  FileNotFoundException {
          ArrayList<String> list = create_list_from_file(args[0]);
          System.out.println(list);
      }
  
      public static ArrayList>String> create_list_from_file(String filename)
          throws  FileNotFoundException {
          File file = new File(filename);
          ArrayList>String> list = new ArrayList<>();
          Scanner input = new Scanner(file);
          while (input.hasNext()){
              list.add(input.next());
          }
          return list;
      }
  }
  
  $ java FileToList.java fruit.txt 
  [grapes, pears, oranges, cranberries, apples, melons, blueberries]

Stopping Execution of a Loop

• The loop header determines how a loop
• In a for loop it tells the number of times the loop will run
• In while and do/while loops it gives the condition that will make the loop stop
• But sometimes there are special situations where you want another way to stop running the loop code
• Java has two statements that can do this
  • continue
  • break

The break Statement

• Sometimes you will come across a situation where you simply want a loop to stop running
• To jump completely out of he loop you would use a break statement

The continue Statement

• Maybe you don't want to jump completely out of the loop
• You just want to stop running the loop code for one iteration of the loop
• In that case you would use a continue statement

The switch Statement

• Whenever the path taken through the code is different depending on the value of a particular expression we can use a switch statement
• It has the following format

  
  switch(EXPRESSION) {
    case VALUE_1:
      STATEMENT;
      STATEMENT;
      ...
      break;
    case y:
      STATEMENT;
      STATEMENT;
      break;
    ...
    default:
      STATEMENT;
      STATEMENT;
  }

• In other words, each value runs a different set of statements

New Material

Writing Better Programs

• The academic discipline of computer science studies many things
• One field of study is how to design the look and feel of a program
• The goal is to make programs intuitive and easy to us
• Another field of study is software engineering
• It studies the best way to design, develop and maintain software
• In the early days of programming the organization of code was left to individual programmers
• The programs did not have much structure and were hard to read
• Researches in software engineering began to think of better approaches
• One technique was to break up a big program into a individual methods
• Functions are what Java calls methods
• This is sometimes called procedural programming
• This made programs easier to read
• It also made the programs easier to debug
• Because all the code that did a particular thing was is one place
• The first part of debugging is finding where the error occurs
• Well designed functions or methods make the program easier to narrow the search for the problem

Object Oriented Programming

• The key idea behind object oriented programming is that certain variables naturally go together
• And certain methods are needed to operate on these variables
• To create an object you need to define a class
• A class is a template that Java uses to create individual objects
• The objects are the things in memory
• But the class is the blueprint used to create individual objects
• The class defines all variable and methods inside the object
• Every class must have a special method which is used to create an object of the class
• This special method is called a constructor
• The object of a given class created by the constructor is called an instance

Objects and Values

• A variable can only hold one value
• Such as a Social Security number
• But objects can hold many values
• Think of the variables we would need to describe a car
• This list might include
  • make (Honda)
  • model (CRV)
  • color (Blue)
  • year (1997)
  • miles (58,000)
• The make, model and year can't change
• But all the other values can
• So I will need methods to update them
• Putting all the variables describing one thing in a single class makes it easier to work with these values

Classes and Objects

• There are two types of classes
  • Static classes
  • Classes that create objects
• A static class cannot create objects
• There are two ways to use a static class
  • As a container for methods and constants
  • As a class containing a method
• The static class Math is an example of the first kind of static class
• It's like a toolbox of useful things that you can bring to any project
• All the classes that we have written up to now have been static classes
• We didn't use these classes to create an object
• We used them as container for a main method which did the work needed
• Most Java classes are not static
• They are templates used to create objects
• Each class of this type has
  • Variables to hold values
  • Methods that work with those values
  • Special methods to create an object of the class
• Up until now we have written one class for each program
• Real world Java programs have many classes
• A Java program for a car dealership might have the following classes
  • A driver class containing the main method
  • A Carclass
  • A Customer class
  • An Invoiceclass
  • A SalesPerson class
  • A RepairOrder class
  • A Part class

Point Objects

• Java has a class called Point
• A Point object represents a point on the 2 dimensional plane
• The class is contained in the java.awt package
• So you need to import it into any program that uses it

  import java.awt.Point;

• A point on the plane is specified by two values
  • The x coordinate
  • The y coordinate
• In the Point class these values are represented by integers
• To create a Point object you have to call the constructor like this

  Point p = new Point(3, 8);

• When this is done, the situation in RAM looks like this

• We can print the Point object p like this

  System.out.println(p);

• and get the following result

  java.awt.Point[x=3,y=8]

• To move a Point object we can use the translate method which takes two arguments
  • The change in the x position
  • The change in the y position
• Here is the statement

  p.translate(–1, –2);

• This is what we have in RAM after we do this

• Here's a small program that uses Point objects

  import java.awt.Point; 
  
  public class PointExample { 
      public static void main(String[] args) { 
          Point p = new Point(3, 8); 
          System.out.println("initially p = " + p); 
          p.translate(-1, -2); 
          System.out.println("after translating p = " + p); 
      } 
  }
  
  $ java  PointExample
  initially p = java.awt.Point[x=3,y=8]
  after translating p = java.awt.Point[x=2,y=6]

• Some of the more useful methods of the Point class are

  Method	Description
  translate(dx, dy)	Translates the coordinates by the given amounts
  setLocation(x, y)	Sets the coordinates to the given values
  distance(p2)	Returns the distance from this point to p2

• You can also access the position values directly using dot notation

  int sum = p.x + p.y;
  System.out.println("Sum of coordinates = " + sum);

• You can even change the values directly

  p.x = 12;
  p.y = 15;

• But this is now considered a bad idea

Defining a Class

• When writing a class we have to give it four things
  • Fields
  • Methods
  • Constructors
  • Encapsulation
• Fields hold the values of the variables
• Methods work on the values contained in fields
• Constructors are special methods that create objects
• Encapsulation are like permissions
• It determines which other classes can use the fields, methods and constructors
• Here is the format for a class declaration

  public class CLASS_NAME {
      FIELD
      FIELD
      ...
      METHOD
      METHOD
      ...
  }

• This code must be in a separate file with a filename using the following format

  CLASS_NAME.java

Fields

• Fields hold an object's values
• You can think of them as variables inside the object
• Fields are declared outside the object's methods
• That means they can be used by any of the methods in an object
• You declare a field the same way you declare a local variable inside a method

  DATA_TYPE  FIELD_NAME;

• Fields are at the top of the class right after the class header
• The fields in a class have the same default values as they do in arrays

  Type	Value
  int	0
  double	0.0
  char	'\0'
  boolean	false

• Another name for a field is an instance variable
• They are sometimes called attribute

Defining a Point Class

• We will now develop our own version of the Point class, but we will do it in stages
• Here is our first attempt at creating our own Point class

  public class Point1 {
      int x;
      int y;
  }

• It has no constructor, but you can access the field directly using dot notation
• The fields can be accessed by any method in the class
• Since they belong to the class, not any one method
• The methods that use or change the field values are not static
• As written here, anyone can access the fields directly using dot notation
• After we have created an object of the Point1class we can do something like this

  p.x = 7;
  p.y = 2;

• For various reasons this is not a good idea
• But I wanted to show you the simplest possible implementation of the class
• We will change this later
• The Point1 class is not executable because it has no main method
• We have to create another class to make use of the Point1 class
• This class will just have a main method
• It will create a object of the Point1 class and print it's values
• Such a class is often called a driver

  public class Point1Driver{
      public static void main(String[] args) {
          Point1 p = new Point1(); 
          p.x = 7; 
          p.y = 2; 
          System.out.println("p is (" + p.x + ", " + p.y + ")"); 
      } 
  }
  
  $ java Point1Driver
  p is (7, 2)

• Point1Driver.java has to be in the same directory as Point1.java or it will not compile

Adding Methods to Our Point Class

• We need to create methods that can work with the data contained in the object
• Methods that can work with the fields inside an object are called instance methods
• Here is the format for the header of an instance method

  public DATA_TYPE METHOD_NAME(DATA_TYPE PARAMTER_NAME, ...) {
  	STATEMENT;
  	...
  }

• Let's write a method to change the position of the point
• We will call it translate and it will have the following header

  public void translate(int dx, int dy)

• After we create this instance method we can call it from the driver class using dot notation

  p.translate(1, -3);

• The method has two parameters, dx and dy which give the change in each coordinate
• We don't need to pass the Point object itself
• Because the method is contained in the class where the fields are defined
• Instance method headers do not use the static keyword
• They only work on the values inside their own object
• We still include the public keyword
• If we did not other Java code could not use it
• Notice that the return type is void
• The method does not return a value
• Instead it changes the values contained in the object's fields
• The pseudocode for this instance method looks like this

  public void translate(int dx, int dy) {
      add dx to this Point object’s x value.
      add dy to this Point object’s y value.
  }

• Here is the new version

  public class Point2{
      int x;
      int y;
  
      public void translate(int dx, int dy) {
          x += dx;
          y += dy;
      }
  }

• Here is the driver class to test our new version

  public class Point2Driver{
      public static void main(String[] args) {
          Point2 p = new Point2(); 
          p.x = 7; 
          p.y = 2; 
          System.out.println("p is (" + p.x + ", " + p.y + ")"); 
          p.translate(-2, 3);
          System.out.println("p is (" + p.x + ", " + p.y + ")"); 
      } 
  }
  
  $ java Point2Driver
  p is (7, 2)
  p is (5, 5)

Class Quiz

Attendance

Class Exercise