Java Data Types: A Comprehensive Overview

1. Data Types in Java Java’s Central Casting CS 102-02 Lecture 3-1

2. Are You Java’s Type? • Type: a set of values that are semantically similar • Java is a strongly typed language • Every variable and every expression has a type that is known at compile time. • Strong typing helps detect errors at compile time.

3. What’s the Role of Types? • Types limit the: • Values that a variable can hold or that an expression can produce • Limit the operations supported on those values • Determine the meaning of the operations.

4. Java Types • Primitive types • boolean • numeric • Integral: byte, short, int, long, and char • Floating-point: float and double • Variables of primitive types hold the actual value

5. Inside a Primitive Type • Actual values for integral types: byte: -128 to 127 short: -32768 to 32767 int: -2147483648 to 2147483647 long: -9223372036854775808 to 9223372036854775807 char: from '\u0000' to '\uffff’ (from 0 to 65535) • Why use int instead of long?

6. Boolean Type • boolean type represents a logical quantity with two possible values, indicated by the literals true and false

7. Building a Boolean from a Number • Can’t say (why not?): if (x) System.out.println(“Congratulations, it’s a Boole!”); • Convert an integer x (following the C language convention that any nonzero value is true): if (x != 0) System.out.println(“Congratulations, it’s a Boole!”);

8. Building a Boolean from an Object • Object reference obj can be converted (any reference other than null is true): obj! = null

9. The Other Kind of Type • Reference types • Variables of reference types don’t hold values, but references to values • Classes, interfaces and arrays are all reference types

10. A Graphical View 0010010 int counter Airport midway 1110010 The data of the midway object

11. Classes, Interfaces and Arrays, oh my! • Classes we’ve already seen • Interfaces are programming contracts • An interface is a set of constants and methods • In Java, a class implements an interface

12. Implementing an Interface • An example from the Comparison applet: public class Comparison extends Applet implements ActionListener • Comparison promises to do everything an ActionListener does

13. Comparison Does What It Has To • What does an ActionListener have to do? actionPerformed public abstract void actionPerformed(ActionEvent e) • Provides an implementation for the interface: public void actionPerformed(ActionEvent e) { number1 = Integer.parseInt(input1.getText() ); number2 = Integer.parseInt(input2.getText() ); repaint(); }

14. Comparison Object has Two Types • Comparison is a class that implements an interface: public class Comparison extends Applet implements ActionListener

15. Interface Type Example • From the Comparison applet: input2 = new TextField( 10 ); input2.addActionListener( this ); add( input2 ); // put input2 on applet • What is addActionListener()? public synchronized void addActionListener(ActionListenerl)

16. Sideline Events • Events are things that happen to programs (other than errors) // Process user's action on the input2 // text field public void actionPerformed(ActionEvent e) { number1 = Integer.parseInt( input1.getText() ); number2 = Integer.parseInt( input2.getText() ); repaint(); }

17. Classes & Interfaces • Class type T can hold: • Null reference • Reference to an instance of class T or of any class that is a subclass of T. • Interface type can hold: • Null reference • Reference to any instance of any class that implements the interface.

18. Array Types • If T is a primitive type, then a variable of type "array of T"can hold: • Null reference • Reference to any array of type "array of T" • If T is a reference type, then a variable of type "array of T" can hold: • Null reference • Reference to any array of type "array of S" such that type S is assignable to type T

19. Object is the Root of All Java • Variable of type Object can hold: • Null reference • Reference to any object, whether class instance or array.

20. Class  Type • Variables have types • Objects (and arrays) don’t have a type, but belong to a class • Usually we’ll consider them the same

21. Casting Against Type • A value could be two different types • Is 12 an int or a float? • Compiler isn’t smart, so it’s conservative (signals an error) • Override the compiler with a cast • Cast says: Treat this variable as the type I say • To cast in Java, write: (newType) variable

22. Examples of casting // Casting a float literal to a type int. // Without the cast operator, this would be a // compile-time error, because it’s a narrowing // conversion: int i = (int)12.5f; // From class average applet (Figure 2.9) if ( counter != 0 ) { average = (double) total / counter; System.out.println( "Class average is " + average ); } else ...

23. Can’t Always Cast • Can’t do this: if ((boolean) x) System.out.println(“Congratulations, it’s a Boole!”); • Sometimes casts are automatic, and are called conversions

24. One of Two Ways • Create an expression in a context where the type of the expression is not appropriate and either: • Error at compile time (if statement has any type other than boolean) • May be able to accept a type that is related to the type of the expression

25. Automatic Conversion • For convenience, Java performs an implicit conversion • From the type of the expression to a type acceptable for its surrounding context • Kinds of conversions: • Identity, Widening primitive, Narrowing primitive, Widening reference, Narrowing reference, String

26. Funky Conversions • What does this print? class Test { public static void main(String[] args) { int big = 1234567890; float approx = big; System.out.println(big -(int)approx); } }

27. Coming Attractions • Arrays: Grouping related values together • Back to objects for a bit