Topics

Review

• Augmented Assignment Operators
• Updated Order of Precedence
• Storing More Than One Value
• Getting Values from an Array
• The Length of an Array
• Creating an Array Object
• Initializing Arrays
• Changing Array Elements
• Index Errors
• What Is an Array Variable?
• Limitations of Arrays

New Material

• Objects
• Strings
• We Have Been Defining Unusual Classes
• Two Kinds of Methods
• Dot Notation
• String Methods
• charAt(index)
• equals(string)
• contains(text)
• length()
• replace(text_1, text_2)
• split(text)
• startsWith(text) and endsWith(text)
• substring(start_index, stop_index
• toLowerCase() and toUpperCase()
• trim()

Homework 6

Homework 6 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.

Homework 6

I have posted homework 6 here.

It is due this coming Sunday at 11:59 PM.

Mid-term

The mid-term exam will be given on Monday, March 23rd.

It will consist of questions like those on the quizzes along with questions asking you to write short segments of Java code.

60% of the points on this exam will consist of questions from the Ungraded Class Quizzes.

The other 40% will come from four questions that ask you to write a short segment of code.

The last class before the exam, Friday, March 13th, will be a review session.

You will only be responsible for the material in the Class Notes for that class on the exam.

The Mid-term is a closed book exam.

Due Date for Homework Assignments 2 - 6

The due date for homework assignments 2 - 6 is Friday, March 20th at 11:59 PM.

That is the Friday of the Spring Break.

Any of these assignments submitted after that date will receive a score of 0.

Review

Augmented Assignment Operators

• One of the most common operations in programming is increasing the value of a variable by 1
• This is called incrementing
• Sometimes we want to decrease the value of a variable by 1
• This is called decrementing
• Java provides special assignment operators that combine shortcuts to change the value of a variable with a simple arithmetic operation
• These operators are called augmented assignment operators
• They are

  Expression	Read As
  x  +=  2	add 2 to x
  x  -=  2	subtract 2 from x
  x  *=  2	mulitply x by 2
  x  /=  2	divide x by 2
  x  %=  2	take the remainder when x is divided by 2

Updated Order of Precedence

• All assignment operators have the lowest precedence of any operator we have studied

  Description	Operators
  Unary operators	!   ++   --
  Multiplicative operators	*   /   %
  Additive operators	+   -
  Relational operators	<   >   <=   >=
  Equality operators	==   !=
  Logical AND	&&
  Logical OR	||
  Assignment operators	=   +=   -=   *=

Storing More Than One Value

• A variable can only hold one value
• But objects can hold as many values as you wish
• For situations like Java has a special kind of object called an array
• The values in an array are stored one after another
• You can get each value in the array by using its position in the sequence of values

Getting Values from an Array

• Every value inside an array has its own unique position in the array
• We can get that value using the [ ] operator
• You place this operator right next to the end of the array variable
• And put a number inside it to specify which value you want
• The values in an array are called elements
• The number put inside the square brackets is called an index
• Unfortunately, the number used to get the first element of an array is 0
• This is called zero based indexing
• For this reason, the index of the last element of an array is one less than the length of the array
• As you learned earlier, the agrs parameter contains all the strings on the command line
• agrs is an array of strings
• So we can use the [] operator to get each command line argument

  public class Print3Args {
      public static void main (String[] args){
           System.out.println(args[0]);
           System.out.println(args[1]);
           System.out.println(args[2]);
      }
  }
  
  $ java Print3Args foo bar bletch
  foo
  bar
  bletch

The Length of an Array

• We can use a for loop to get each value in an array but we have to know the length of the array to do it
• One of the pieces of information in an array object is its length
• You can get this value using the following format

  
  ARRAY_VARIABLE.length

• To get the length of args we would use

  args.length

• Here is an example

  public class PrintArgs {
      public static void main (String[] args){
          for (int i = 0; i < args.length; i++){
              System.out.println(args[i]);
          }
      }
  }
  
  $ java PrintArgs 1 2 3 4 5
  1
  2
  3
  4
  5

Creating an Array Object

• All the elements of an array must be of the same data type
• And you must say how many elements the array will hold when you create it
• You create an array variable using the following format

  
  DATA_TYPE int VARIABLE_NAME = new DATA_TYPE[LENGTH];

Initializing Arrays

• If you create a variable of a primitive data type you must give it a value before you use it
• When you do this we say you have initialized the variable
• Array elements are automatically initialized when they are created with default values
• This is feature of Java is called auto-initialization
• For an array of each data type there is a different default value

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

• You can also initialize an array with an array literal
• It has the format

  
  {VALUE, VALUE, ...}

Changing Array Elements

• You can think of each element in an array as a variable
• You change the value of a variable like this

  
  VARIABLE_NAME = NEW_VALUE

• Similarly you can change the value of an array element like this

  
  VARIABLE_NAME = NEW_VALUE[INDEX]

• The INDEX is an integer running from 0 to one less than the length of the array

Index Errors

• The indexes of an array run from 0 to 1 less than the length of the array
• If you try to go past the end of an array you will get an error

What Is an Array Variable?

• Like all objects, arrays do not have a name
• They have a position in memory
• The statement that creates an array returns a memory address
• We need to store this position in a variable so we can work with the array
• The variable does not hold the values in the array
• It holds the memory address where the array exists in RAM
• The picture in memory looks like this

Limitations of Arrays

• Arrays have a number of limitations
• The two most important are
  • Each element must be of the same data type
  • The length of a list cannot be changed
• The last issue is the most troublesome
• You have to know how many values the array will hold when you create it
• What if you were reading in values from a file?
• You would either have to count the values before creating the array
• Or make the array so big that it can hold any reasonable number of values
• There are way around this, but we'll leave that for another class

New Material

Objects

• Objects are sections of RAM that can contain more than one value
• They can also contain methods that act upon there values
• These values are called attributes or fields or properties
• Objects do not have a name, just a position in RAM
• When you create an object its position must be stored in a variable
• Otherwise you will not be able to use the object
• The values and methods an object contains are defined by a class
• Classes serve as the template or blueprints used to create an object
• Java is an object-oriented language
• A program in Java consists of one or more files
• Each of these files contain at least one class

Strings

• Strings are objects because they contain many values
• What are the values?
• The characters that make up the string
• The format for declaring and initializing an array is

  
  String VARIABLE_NAME = STRING_LITERAL;

• A is a sequence of letters written out inside a Java program
• String literals must be enclosed in double quotes, "

  String greeting = "Hello";

• Two strings can be joined to form a third string using concatenation
• This is done using the concatenation operator, +

  System.out.println(greeting + "John");

We Have Been Defining Unusual Classes

• All the Java programs you have seen so far are unusual
• Because they cannot be used to create an object of their class
• We will talk more about this in a future class
• All other Java classes can be used to create an object of their class

Two Kinds of Methods

• A method is a collection of statements that perform a specific task
• All methods are defined inside a class
• In Java you can define two kinds of methods
  • Methods that work with the values inside an object
  • Methods that do not work with values inside an object
• Methods of the first type can only be used on an object that you create from the class
• These are the most common type of Java methods
• The second type are called static methods
• When we created programs to turn scores into grades we called a method to convert string values into integers

  number = Integer.parseInt(input);

• parseInt is a method of the Integer class
• We did not have to create an Integer object to use this method
• Similarly when we created the rand_int method for our dices games, we did not have to create an object
• The method declaration looked like this

  public static int rand_int(int max, int min){
      double value = Math.random() * (max - min)  + min;
      return (int) value;
  }

• The keyword static means an object does not have to be created to use this method
• In a certain sense, static methods live inside a class
• While all other methods live inside their objects

Dot Notation

• The program DiceGame2.java contained the method rand_int shown above
• The program called rand_int like this

  die_1 = rand_int(7, 1);
  die_2 = rand_int(7, 1);

• But in another program where we needed to convert a string to integer we wrote

  int score = Integer.parseInt(input);

• What's going on
• When we are calling a method defined inside the current class we just use the name of the method
• When we call a method outside the current class we have to use dot notation
• Dot notation has the following format

  
  CLASS_NAME_OR_OBJECT_NAME.METHOD_NAME(PARAMETER_LIST

• When we are calling a static method we use the name of the class before the dot

  int score = Integer.parseInt(input);

• For all other method calls we use the name of the variable pointing to the object

  String name = "John Smith"
  System.out.println(name + " is " name.length() + " long");

String Methods

• Here is a list of some of the more useful String methods

  Method	Description	Return Type
  charAt(index)	Returns the character at a specific position	char
  contains(text)	Returns true if the string contains the text	boolean
  endsWith(text)	Returns true if the last characters in the string are text	boolean
  equals(string)	Returns true if the two strings are equal	boolean
  length()	Returns the number of characters in the string	int
  replace(text_1, text_2)	Returns a new string where all the occurrences of text_1 are replaced by text_2	String
  split(text)	Returns an array of strings. The text is used to mark off each string from the next	String []
  startsWith(test)	Returns true if the the first characters of the string are text	boolean
  substring(start_index, stop_index)	Returns a string starting at the position of start_index and ending just before stop_index	String
  toLowerCase()	Returns a new string will all characters lowercase	String
  toUpperCase()	Returns a new string will all characters UPPERCASE	String

charAt(index)

• A string is like an array of characters
• But you can't use the [] operator with strings
• You use the charAt method instead
• As with arrays you use zero-based indexing
• So the index of the first character is 0
• And the index of the last character is 1 less than the length

  public class CharAt {
      public static void main (String[] args){
          String name = "Tom";
          System.out.println("name " + name);
          System.out.println("name.charAt(0) " + name.charAt(0));
          System.out.println("name.charAt(1) " + name.charAt(1));
          System.out.println("name.charAt(2) " + name.charAt(2));
      }
  }
  
  $ java CharAt 
  name Tom
  name.charAt(0) T
  name.charAt(1) o
  name.charAt(2) m

equals(string)

• The equals method compares two strings and returns true if they are equal

  public class StringEquals {
      public static void main (String[] args){
          String string_1 = args[0];
          String string_2 = args[1];
          System.out.println(string_1.equals(string_2));
      }
  }
  
  $ java StringEquals foo foo
  true
  
  $ java StringEquals foo bar
  false

contains(text)

• contains returns true if its argument is contained within the string

  public class StringContains {
      public static void main (String[] args){
          String string = args[0];
          String text   = args[1];
          System.out.println(string.contains(text));
      }
  }
  
  $ java StringContains Mississippi pp
  true
  
  $ java StringContains Mississippi ss
  true
  
  $ java StringContains Mississippi q
  false
  

length()

• length returns the length of the string
• We can use length along with charAt to loop through the characters in a string

  public class StringLoop {
      public static void main (String[] args){
          String name = "Tommy";
          System.out.println(name);
          for (int i = 0; i < name.length(); i++){
              System.out.println("name.charAt(" + i + ") " + name.charAt(i));
          }
      }
  }
  
  $ java StringLoop 
  Tommy
  name.charAt(0) T
  name.charAt(1) o
  name.charAt(2) m
  name.charAt(3) m
  name.charAt(4) y

replace(text_1, text_2)

• replace takes two strings as it arguments
• It returns a new string where every occurence of the first string is replaced by the second string

  public class ReplaceString {
      public static void main (String[] args){
          String string   = args[0];
          String old_text = args[1];
          String new_text = args[2];
          System.out.println(string.replace(old_text, new_text));
      }
  }
  
  $ java ReplaceString Mississippi ss s
  Misisippi
  
  $ java ReplaceString Hoffman,Glenn , " "
  Hoffman Glenn

split(text)

• split splits a string into an array of strings
• In order to spilt the string into small sub-strings we need to know characters to use as the border between adjacent sub_strings
• The string that serves as the boundary is called a delimiter
• For example say we had the following string

  "John, Smith, 0124353"

• Here the delimiter is ", "
• The code below shows split in action

  public class SplitString {
      public static void main (String[] args){
          String string    = args[0];
          String delimiter = args[1];
          String [] fields = string.split(delimiter);
          for (int i = 0; i  fields.length; i++){
              System.out.println(fields[i]);
          }
      }
  }
  
  $ java SplitString "John, Smith, 0124353" ", "
  John
  Smith
  0124353
  
  $ java SplitString "2020-01-10" "-"
  2020
  01
  10
  

• Notice the different ways we get the length of a string

  string.length()

• Versus an array

  fields.length

• That's because strings use a method to get the length
• While array store the value in a variable inside the object

startsWith(text) and endsWith(text)

• startsWith returns true if its argument is the first few characters in the string

  public class StartsWith {
      public static void main (String[] args){
          String string = args[0];
          String text   = args[1];
          System.out.println(string.startsWith(text));
      }
  }
  
  $ java StartsWith Mississippi M
  true
  
  $ java StartsWith Mississippi Mis
  true
  
  $ java StartsWith Mississippi m
  false
  
  $ java StartsWith Mississippi q
  false

• endsWith returns true if its argument matches the last few characters in the string

  public class EndsWith {
      public static void main (String[] args){
          String string = args[0];
          String text   = args[1];
          System.out.println(string.endsWith(text));
      }
  }
  
  $ java EndsWith Mississippi ppi
  true
  
  $ java EndsWith Mississippi pp
  false
  

substring(start_index, stop_index

• A substring is a string contained within another string
• The substring method returns a part of another string
• It takes two integer arguments
• The first argument is the position where the substring you want begins
• The second argument is one more than the position where the substring you want ends

  public class Substring {
      public static void main (String[] args){
          String string   = args[0];
          int start_index = Integer.parseInt(args[1]);
          int end_index   = Integer.parseInt(args[2]);
          System.out.println(string.substring(start_index, end_index));
      }
  }
  
  $ java Substring Mississippi 2 5
  ssi
  
  $ java Substring Mississippi 0 5
  Missi
  
  $ java Substring Mississippi 5 11
  ssippi
  

toLowerCase() and toUpperCase()

• toLowerCase returns a new string where all the letters in the string a turned lowercase
• It does does not change characters that are not letters

  public class ToLowerCase {
      public static void main (String[] args){
          String string = args[0];
          System.out.println(string.toLowerCase());
      }
  }
  
  $ java ToLowerCase UPPERCASE
  uppercase
  
  $ java ToLowerCase lowercase
  lowercase
  
  $ java ToLowerCase 123
  123
  
  $ java ToLowerCase '%$#@'
  %$#@
  
  $ java ToLowerCase lower123%^UPPER
  lower123%^upper

• toUpperCase returns a string where all the lowercase letters are uppercase
• And does not change any characters that are not letters

  public class ToUpperCase {
      public static void main (String[] args){
          String string = args[0];
          System.out.println(string.toUpperCase());
      }
  }
  
  $ java ToUpperCase lowercase
  LOWERCASE
  
  $ java ToUpperCase UPPERCASE
  UPPERCASE
  
  $ java ToUpperCase 123
  123
  
  $ java ToUpperCase %$#@
  %0@
  
  $ java ToUpperCase lower123%^upper
  LOWER123%^UPPER

trim()

• trim returns a new string with whitespace characters from the beginning and end of the string removed
• The whitespace characters are

  Space	' '
  Tab	'\t'
  Newline	'\n'

• Here is an example

  public class Trim {
      public static void main (String[] args){
          String string_1 = "  hello ";
          String string_2 = "\tthere\t";
          String string_3 = "\nworld\n";
          show_string_boundaries(string_1);
          show_string_boundaries(string_1.trim());
          show_string_boundaries(string_2);
          show_string_boundaries(string_2.trim());
          show_string_boundaries(string_3);
          show_string_boundaries(string_3.trim());
      }
  
      public static void show_string_boundaries(String s){
          System.out.println("---" + s + "---");
      }
  }
  
  $ java Trim
  ---  hello ---
  ---hello---
  ---  there  ---
  ---there---
  ---
  world
  ---
  ---world---

Class Quiz

Attendance

Class Exercise