Types 1

• What are types?
• Types in Java
• Static and dynamic typing
• Type conversions
• Super- and subtypes

What Are Types?

• Type = set of values + permitted operations on these values
• Example: int in Java. Set of numbers between Integer.MIN_VALUE and Integer.MAX_VALUE. Operations +, -, *, etc.
• Used for
  • IDE help
  • Code generation
  • Error handling

Types in Java/Scala

• 8 primitive types: int short long byte char float double boolean
• Every other type is a reference type
• Classes
• Interfaces
• Arrays
• These are types of variables. Values cannot have interface type, but they can be null. (Null type)
• Additional Types in Scala
  • Tuple types (String, Int)
  • Function types (String, String) => Int

Strong Typing

• Strong typing: Compiler and run-time system guarantee that no type error can occur in a program
• Example: Compiler catches "Hello".println(). String has no such method
• Not all Java errors are caught at compile-time.

  String[] words = { "Hello", "World" };
  Object[] objs = words; // compiles: Can convert String[] to Object[]
  objs[0] = new Watermelon(); // compiles. Can convert Watermelon to Object
  // Oops: Now words[0] is a Watermelon!

  Causes ArrayStoreException at run-time.

• C/C++ are not strongly typed:

  int luckyNumbers[] = { 17, 29 };
  double* values = (double*) luckyNumbers; // compiles
  double x = values[0]; // may not be a legal floating-point value

Static and dynamic typing

• Static typing: All type errors are caught at compile-time; program will never raise a type error at run-time.
• Java is mostly, but not fully statically typed: NullPointerException, ArrayStoreException
• Some languages are much more dynamic than Java. Ex. JavaScript

  val x = "Hello"
   ...
  x = new Duck();
   ...
  x.quack()

  Variables have no types, but values do. Errors caught at run-time ("Duck typing").

• Scala is like Java

  val x = "Hello" // x is inferred to be String

Type Conversions

• Type conversion: Converts between type, usually by changing data representation
• Example: int → double changes from 2's complement to IEEE floating point
• Example: Autoboxing int → Integer
• Automatic conversion: Compiler inserts conversion instructions

  int n = 17;
  double x = n;
  Double d = x;

• Cast: Programmer directs compiler to insert conversion instructions

  n = (int) x;

• Usually done when conversion can lose data
• Programmer-defined conversions
  • C++: single-argument constructors, operator functions
  • Scala: implicit functions

    implicit def makeAction(action : (ActionEvent)=>Unit) = new ActionListener {
      def actionPerformed(event: ActionEvent) { action(event) } 
    }

Subtypes

• S is subtype of T if S's specification implies T's specification
• Example: InputStream has method read with defined behavior (returns next byte, -1 at end of stream)
• FileInputStream has method read with same behavior
• Subtype may have additional behavior that is not specified by supertype
• Subtype values can be substituted when supertype values are expected

  public void read(InputStream in) // Ok to call with FileInputStream object

Subtypes in Java

• Java Language Specification: http://java.sun.com/docs/books/jls
• Gives all the rules for the Java language
• Subtypes defined in section 4.10

  • The subtype and supertype relations are binary relations on types. The supertypes of a type are obtained by reflexive and transitive closure over the direct supertype relation, written S >₁ T, which is defined by rules given later in this section. We write S :> T to indicate that the supertype relation holds between S and T.

• Supertype is a bit more convenient than subtype because :> goes in the same direction as assignment
• If S :> T, s is a variable of type S, t is a variable of type T, then the assignment s = t is ok
• If T extends S or T implements S, then S >₁ T
• If S :>₁ T, then S[] :>₁ T[]
• Object :>₁ S[]

Transitive Relations

• If S is any set, then a relation R is a map S x S → boolean.
• We usually write x R y instead of R(x, y) = true (infix notation)
• R is transitive if

  x R y and y R z ⇒ x R z

• Example: > of integers is transitive
• >₁ is not transitive:
  • Object >₁ InputStream
  • InputStream >₁ FileInputStream
  • But Object is not a direct supertype of FileInputStream
• Want to make it transitive

Transitive Closure

• If R is any relation, define the transitive closure T as follows:

  x T y is true if there are elements x₁, x₂, ... x_n such that

  x R x₁, x₁ R x₂, ..., x_{n - 1} R x_n, x_n R y

• Fact: T is transitive

Example: If R is >₁ and T is :>, then Object :> FileInputStream because there is a chain

• Object >₁ InputStream >₁ FileInputStream

Lab

• This lab uses Java, not Scala
• Check into eCampus in the usual way
• Scribe puts in report
• Buddy puts in comment with scribe's name

Step 1: Type Conversions

1. Consider this simple Java program.

   public class Test
   {
      public static void main(String[] args)
      {
         int x = 1729;
         double y = x;
      }
   }

   Compile and run javap -c Test. Which virtual machine instruction is implicitly generated to carry out the type conversion?

2. Now change the body of main to

         double x = 17.29;
         int y = (int) x;

   Compile and run javap -c again. Now which virtual machine instruction is generated for the conversion?

3. Why did the compiler require a cast only in the second example even though a type conversion was carried out in both cases?

Step 2: Autoboxing

1. Change the body of main to

         int x = 1729;
         Integer y = x;

   What code is generated for the type conversion?

2. Now change the body of main to

         Integer x = 1729;
         Integer y = x + 1;

   What code is generated for auto-unboxing?

3. Integer objects are immutable, but you can call x++ on an Integer x. Use javap -c to find out what actually happens. What was your sample program, what is the relevant part of the disassembly output, and why does that not contradict the immutability of Integer objects?

Step 3: Subtypes

Consider variables

Object o = null;
Object[] oa = null;
InputStream i = null;
InputStream[] ia = null;
FileInputStream f = null;
FileInputStream[] fa = null;

1. Write down what you think are the direct supertype relationships between the six types Object, Object[], ... FileInputStream[], using the >:1 notation
2. Write down what you think are the indirect supertype relationships (that is, all >: that are not >:1) between the six types Object, Object[], ... FileInputStream[]
3. Place the variable declarations and 30 assignment statements o = oa; o = i; o = ia; o = f; o = fa; oa = o; oa = i; oa = ia; oa = f; oa = fa; i = o; ... into a main method and compile. You should get an error message for each line that does not correspond to a supertype relationship. Did you find an error in your list in step 2? (Most people do.) If so, which?
4. Consider a main program with this body:

   FileInputStream f = new FileInputStream("Test.java");
   InputStream i = f;

   Run javap -c and peek at the byte codes. What type conversion instruction did the compiler generate?

Step 4. Array Variance

Consider this program.

import java.io.*;
import java.net.*;

public class Test
{
   public static void main(String[] args) throws MalformedURLException,
      IOException
   {
      FileInputStream[] fa = new FileInputStream[2];
      InputStream[] ia = fa;
      ia[0] = new URL("http://horstmann.com").openStream();
   }
}

1. Does it compile? If so, do you get any warnings? If not, do you get any compiler errors?
2. What happens when you run the program?
3. Explain the reason for the exception.