Type Conversion, Constants, and the String Object CS0007: Introduction to Computer Programming

Review Integer Data Types Floating-Point 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 short 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): double float long int short 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 higher- ranked 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: 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: 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);

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: 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. Draw shit here

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()); } }