Download Type Cast Operators

Type Conversion, Constants, and the
String Object
CS0007: Introduction to Computer Programming
Review
 Integer Data Types
 byte
 short
 int
 long
 Floating-Point Data Types
 float
 double
 String Concatenation is…
 the process of appending to the end of a string.
 String Concatenation Operator
 +
Review
 Entities of the boolean data type can have one of two values:
 true
 false
 Entities of the char data type can take one what kind of values:
 Single Characters
 Characters are represented in memory as…
 2 bytes integers
 Character Literals are encapsulated in
 Single Quotes (')
 String Literals are encapsulated in
 Double Quotes (")
Review
 You can declare multiple variables on the same line by
separating them with a…
 Comma (,)
 You can assign a variable a value in the same line as you
declare it through a process called…
 Initialization
 Some Arithmetic Operators
 +, -, *, /, %
 You can do more complex mathematical operations like
square root and exponents with the Math class.
Combined Assignment Operators
 Often you want to do a mathematical operation to the value in a variable and store the
result back into the same variable:
 Computing the sum:
sum = sum + newNumber;
 Counting
count = count + 1;
 Doubling a number:
number = number * 2;
 Many others
 You can shorten these with combined assignment operators:
sum += newNumber;
count += 1;
number *= 2;
 You can do this with any of the mathematical operators.
 There is also an operator to add one to (increment) a variable :
 ++
 Example: sum++;
Sample Segment of Code
number = 5;
number += 2;
System.out.println("number += 2 makes number = " + number);
number -= 3;
System.out.println("number -= 3 makes number = " + number);
number *= 4;
System.out.println("number *= 4 makes number = " + number);
number /= 8;
System.out.println("number /= 8 makes number = " + number);
number++;
System.out.println("number++ makes number = " + number);
number--;
System.out.println("number-- makes number = " + number); } }
Conversion Between Primitive Data
Types
 Java is known as a strongly typed language.
 In a Strongly Typed Language before a value is assigned to a variable, Java
checks the types of the variable and the value being assigned to it to
determine if they are compatible.
 For example:
int x;
double y = 2.5;
x = y;
This will cause an error
int x;
short y;
x = y;
This will NOT cause an error
…but, why?
Conversion Between Primitive Data
Types
 Types in Java have “ranks”.
 Ranks here means that if a type has a higher rank than another, it
can hold more numbers, and thus, will not lose any precision.
 Ranks (Highest to Lowest):
1. double
2. float
3. long
4. int
5. short
6. byte
Conversion Between Primitive Data
Types
 In assignment statements where values of a lower-ranked data
types are stored in variables of higher-ranked data types, Java
automatically converts the lower-ranked value to the higherranked type.
 This is called a Widening Conversion.
double x;
int y = 10;
x = y;
 A Narrowing Conversion is a conversion of a value to a lower-ranked
type.
 These can cause a loss of data, so Java does not automatically perform them.
Imagine converting from double to int…
 You can perform narrowing conversions with type casting operators.

Type Cast Operators
 Type Cast Operators allow you to manually convert from
one type to another, even if it is a narrowing conversion.
 In Java they are unary operators that appear before what you
want to convert.
 They are written as the type you want to convert to in
parentheses.
 Example: x = (int)number;
 If number is of a numeric data type, it will convert the value in number to
the int type and assign that value to x.
 If number is a floating-point type, the fractional part of the value would
be lost converting it to int type and the value assigned to x.
 This is called truncation.
 The value in number would not be changed.
Type Casting
double number1 = 2.0;
int number2;
byte number3;
number2 = (int)number1;
number3 = (byte)number2;
System.out.println("Type Casting with NO Side Effects");
System.out.println("---------------------------------");
System.out.print ("number1 = " + number1);
System.out.print ("number2 = " + number2);
System.out.println("number3 = " + number3 + "\n");
Type Casting with side effects
number1 = 400.59;
number2 = (int)number1;
number3 = (byte)number2;
System.out.println("Type Casting with Side Effects");
System.out.println("------------------------------");
System.out.println("number1 = " + number1);
System.out.println("number2 = " + number2);
System.out.println("number3 = " + number3);
Type Conversion in Arithmetic
Operations
 Recall integer division:
int number1 = 10, number2 = 4;
double number3 = number1 / number2;
number3 will have 2.0 stored in it as a result of the division because both
operands of the division are of type int.
 We can use type casting on one of the operands to make sure the result is a
double:
int number1 = 10, number2 = 4;
double number3 = (double)number1 / number2;
number3 will have 2.5 stored in it as a result of the division because one of
the operands is of type double.
 Note that type casting operators can be applied to expressions enclosed in
parentheses:
int number1 = 10, number2 = 4;
double number3 = (double)(number1 / number2);
number3 will have 2.0 stored in it as a result of the division because the type
casting operator is applied to the result of the integer division, which is 2.
Type Casting Example 2
int number1 = 7, number2 = 4;
double number3;
number3 = number1 / number2;
System.out.println(number1 + " / " + number2 + " = " + number3);
number3 = (double)number1 / number2;
System.out.print((double)number1 + " / " + number2 + " = ");
System.out.println(number3);
number3 = (double)(number1 / number2);
System.out.println(number1 + " / " + number2 + " = " + number3);
Mixed Integer Operations
 One of the problems in Java is that when you use any integer type
in an arithmetic operation, it temporarily converts them to int.
 This can cause problems:
short number1 = 10, number2 = 20, number3;
number3 = number1 + number2;
 The second line will cause an error! Why?
 Because the result of the addition of number1 and number 2 is of the int
type, which is over a higher rank than number3’s type, short.
 Cannot make the narrowing conversion.
 The way to fix this is to cast the entire expression to short:
short number1 = 10, number2 = 20, number3;
number3 = (short)(number1 + number2);
Other Mixed Mathematical Expressions
 When Java sees that an expression has operands of double,
float, or long, it attempts to convert all the operands of
lower rank to that type.
 For Example:
double number1 = 2.5, number3;
int number2 = 4;
number3 = number1 + number2;
 Before the addition number2 is converted to type double,
and the result is a double.
Named Constants
 Imagine you ran into this code:
amount = balance * 0.069;
 What is 0.069?
 An interest rate?
 A fee of some sort?
 Say it is an interest rate, maybe you need to use the rate
multiple times in a program.
 What happens if the interest rate changes?

You need to change it everywhere it is used in the code…
 How can we fix this?
 Answer: Named constants.
Named Constants
 A Named Constant is a variable whose value is read only and cannot be changed





during the program’s execution.
You can create a named constant, declare and initialize it just like any other
variable, but put the key word final in front of the data type:
final double INTEREST_RATE = 0.069;
By convention, programmers tend to make the names of named constants all
capital letters with underscores separating words in the name.
Now, instead of using a literal that is NOT self-documenting, you can use the
named constant:
amount = balance * INTEREST_RATE;
If the interest rate changes to 0.084, instead of having to find every
occurrence of 0.069 in the code, you can simply change the initialization
value:
final double INTEREST_RATE = 0.084;
The Java API provides some useful named constants:
 Example: Math.PI
area = Math.PI * radius * radius;
Named Constants Example
final double ONE_TIME_FEE = 0.005;
double accountBalance = 2000.00, otherAcctBalance = 3500.00;
System.out.println("Balance BEFORE the one time fee: " + accountBalance);
accountBalance = accountBalance - (accountBalance * ONE_TIME_FEE);
System.out.println("Balance AFTER the one time fee: " + accountBalance);
System.out.print("Another Balance BEFORE the one time fee: “);
System.out.println (otherAccountBalance);
otherAcctBalance = otherAcctBalance - (otherAcctBalance * ONE_TIME_FEE);
System.out.print("Another Balance AFTER the one time fee: “);
System.out.println(otherAcctBalance);
The String Class
 We’ve seen strings in the form of string literals:
"Hello World"
 Even though they are very important, String is NOT a
primitive type in Java. The Java API provides a class called
String.
 We’ve talked about classes before:
 Programmers need to create a class that describes the methods
and attributes that make up objects created with the class.
 Again, you can think of classes as being the blueprint that objects may be
created from.
 In other words, a class is not an object but a description of one.
 An object that is created from a class is called an instance of the class.
The String Class
 To declare a string variable:
String variable;
 When you use the String keyword to create a string variable, it is
actually creating a class type variable.
 A Class Type Variable does not hold the actual value of the string, but the
memory address of the data item it is associated with.
 This is represented differently in memory
int number = 25;
 This stores the actual value of 25 in the variable.
String name = "Eric";
 Since this is a class type variable, it holds the memory address of a String
object that holds the value "Eric".
 It is said that the variable references the object, because it holds the memory
location, for this reason class type variables are known as reference variables.
The String Object
 You can store a value in a String object much like you
would store a value into a variable of a primitive type.
String name;
name = "Eric";
 The first line declares the String variable name.
 The corresponding String object is not actually created until
the assignment statement on the second line.
 Again, the variable name references the String object that
holds the value "Eric".
 As seen before, you can also initialize a String variable.
String Variable Example 1
//StringVariables - Uses variables of the String class type
public class StringVariables {
public static void main(String[] args) {
String firstPart = "Hello, ";
String secondPart;
secondPart = "Java Programmers";
System.out.println(firstPart + secondPart);
}
}
String Methods
 Because the String type is a class instead of a primitive
type, it has numerous methods for working with strings.
 The general form for using the methods for a reference
variable is:
referenceVariableName.methodName(arguments…);
 referenceVariableName – name of the reference
variable
 methodName – name of the methods
 arguments… – is zero or more arguments passed to the
method
String Methods
 The length method returns the number of characters in the
string:
stringSize = name.length();
 Here, the variable stringSize is assigned the number of characters in
the string referenced by name.
 The name.length() portion is called a method call.
 To call a method is to execute it.
 The length method is said to return the number of characters as an int.
 A method returns a value if it sends a value back to where it was called.
 There are many methods in the String class. A few include:
 charAt(index);
 toLowerCase();
 toUpperCase();
String Methods Examples
//StringMethods - Shows the usage of various string methods
public class StringMethods {
public static void main(String[] args) {
String name = "Eric Heim";
System.out.println("name.length() = " + name.length());
System.out.println("name.charAt(0) = " + name.charAt(0));
System.out.println("name.charAt(5) = " + name.charAt(5));
System.out.println("name.toLowerCase = " + name.toLowerCase());
System.out.println("name.toUpperCase = " + name.toUpperCase());
}
}