Chapter 2- Variables and Expressions

1
Chapter 2- Variables and Expressions
2
Overview

• Comments
• Variables
• Expressions and operators
• Strings
• Keyboard and Screen I/O
• Documentation

3
Comments
4
Why comments?

• We use comments when we want to put something in
  the program to help a human understand what they
  are reading, but we dont need the computer to
  read the information.
• Use comments whenever you think an area of code
  might need some extra explanation as to what it
  does, or what it is for.
• They are also useful at the beginning of programs
  to identify the programmer and the function of
  the program.

5
2 kinds of comments

• Single line comments - //
• used to cause the computer to ignore everything
  from // to the end of the line.
• Multiple line comments- / some stuff /
• Computer will ignore everything between the /
  and the / marks, even if on separate lines. Good
  way of temporarily removing code from your
  program when trying to find errors.

6
Comment examples.
/ Eric Davis Some commented program Still
in the multiple line comment. / public class
commentProgram public static void
main(String args) System.out.println(Hi
) // print Hi. //another single line comment.

7
Comment guidelines

• In TextPad, comments will usually be a different
  color than the rest of your code (green).
• Use comments to explain what you are doing to
  anyone else that might have reason to read your
  code.
• When in doubt, comment.

8
Variables
9
What are variables?

• Variables are like storage boxes. They have a
  name written on the outside, and they have some
  space to store stuff.
• In programming, these variables hold different
  kinds of data like numbers, characters, and truth
  values (true/false).
• Every variable has a name, a type, and a value.

10
Variable names

• Names cant start with a digit, and can contain
  only letters, digits, and underscores.
• It is a bad idea to have single-letter or short
  variable names. Try to give your variables useful
  descriptive names.
• First word usually starts out lower-case, the
  beginning of every subsequent word is
  capitalized.

• Good names
• userInputChar1
• numberOfApples
• totalDollars

• Bad Names
• 1userInput (invalid)
• x
• st

11
Variable types

• The variables type determines what kind of data a
  variable can store. We will talk about 8
  primitive types and one class type.
• There are 4 integer types byte, short, int, and
  long. int is the usual type for integers.
• There are 2 decimal types float and double.
  double is the usual type for decimal numbers.
• There is 1 type for a single character, char.
• There is 1 type for a true/false value, boolean.
• There is 1 class type for holding sequences (or
  sentences) of characters, String.

12
Declaring variables

• Before a variable is used, it must be declared,
  or given a name and type.
• Write the type of variable first, followed by the
  names of one or more variables that you want to
  have that type.

Type variableName1, variableName2, int
numberOfApples, numberOfStudents char
myGrade double accountBalance,
13
Variable values

• Once a variable has been declared, we can assign
  it a value.
• We can only assign a value to a variable if the
  types match (or if a simple conversion exists).

int numberOfStudents, numberOfApples double
accountBalance numberOfStudents 45 //the 45
is called a constant numberOfApples
12 accountBalance 12 //conversion accountBa
lance 13.45
14
Variable shortcut

• We can do the process of declaring a variable and
  assigning it a value even quicker, in a single
  line

int numberOfApples 45, numberOfStudents15
This is equivalent to the following 3 lines
int numberOfApples, numberOfStudents numberOfAppl
es 45 numberOfStudents 15
15
Converting variables

• You can sometimes assign the value of one type of
  variable to another type of variable, if an
  automatic conversion will occur.
• These automatic conversions occur from numeric
  data types that have less information to those
  that have more. Thus we can assign an integer
  value to a double variable, but not the other way
  around.
• byte-gtshort-gtint-gtlong-gtfloat-gtdouble.

• Valid

• Not Valid

int aNum 1 long bNum aNum float cNum
bNum double dNum cNum
int aNum 1.0 long bNum 2.0 aNum bNum
16
Casting variables

• When we want to copy the data from one type of
  variable to another, and no automatic conversion
  is possible, we can use something called casting.
• To cast a variable to a new type, merely put the
  name of the type inside parentheses in front of
  the variable or constant you want to cast. Java
  will force the conversion for you (might cause
  some data loss).

int aNum (int) 2.5 //stores 2 as an int long
bNum (long)3.2 //stores 3 as a long aNum
(int)bNum //now both hold 3, one //as an
int, the other as a long
17
Expressions
18
Expressions

• Expressions are combinations of variables,
  constants, operators and other expressions that
  get evaluated.
• Examples

2 4 //evaluates to 6. numberOfApples 3 2
(64) 15 numberOfStudents/(numberOfApples 3
2)
19
Expressions and variables

• Whenever a variable is being assigned a value, it
  is always an expression that is on the right side
  of the assignment statement.
• The expression first gets evaluated, and its
  value is assigned to the variable.

numberOfApples numberOfStudents 3
20
Expressions and operators

• To create anything more than trivial expressions,
  we use operators to combine expressions, making
  them larger and more complex.
• We have lots of operators available in Java Math
  operators (, , etc.), Comparison operators (gt,
  , lt), boolean operators (! (not)), and more.

21
Math operators

• , -, , /,
• These operate much like they do in math. They are
  binary operators (they have two operands or
  arguments), so you have to have a constant,
  variable, or expression on either side of each.
  They return a number value.
• , -, work like usual. They add, subtract, and
  multiply two operands.
• / and are a little different.

22
/ Division operator

• The division symbol can do two types of division,
  integer division and floating division (real
  division).
• If both arguments to the division sign are
  integers, then integer division is performed and
  no remainder is returned from the calculation
  (examples on next slide).
• If one or more of the arguments are float or
  double types, then real division is performed
  like usual.

23
Integer division examples.
int numApples 45 int numStudents
15 numApples/numStudents //3 numApples/(numStuden
ts1) //2 numApples/8 //5 //BOTH sides must be
integer values!
4/2 //2 5/2 //2 10/3 //9 20/5 //4 21/5 //4 22/5
//4 23/5 //4 24/5 //4 25/5 //5
24
Real division examples
4/2.0 //2.0 5/2.0 //2.5 10.0/3.0 //9.333 20.0/5
//4.0 21/5.0 //4.2 22.0/5.0 //4.4 23.0/5
//4.6 24/5.0 //4.8 25/5.0 //5.0
int numApples 45 double numStudents
15.0 numApples/numStudents //3.0 numApples/(numSt
udents1) //2.8125 numApples/8 //5 numApples/8.0
//5.625 (double)numApples/8 //5.625 Either side
of the division must be a float or double value.
25
Modulo operator

• One might begin to wonder how you get the
  remainder from integer division. You get it from
  the modulo operator ().
• Examples

42 //0 52 //1 103 //1 205 //0 215 //1
225 //2 235 //3 245 //4 255 //0
26
Comparison operators

• (equals), gt(grtr than or equals), gt, lt, lt,
  !(not equals)
• Compares its two operands according to the
  operator. If the result is true, it returns the
  boolean value true, else it returns false.
• Remember equals has 2 equal signs!

int aNum 5 double bNum 10 boolean
truthaNumgtbNum //False bNum gt aNum //True
54 //False 5!4 //True 5gt4 //True 5lt4
//False
27
Shortcut operators

• There are two kinds of shortcut operators
  modified assignment operators, and
  increment/decrement operators.
• They arent necessary, but they are useful, and
  you should be able to understand them when you
  see them.

28
Modified assignment operators

• Often we just need to change the value of a
  variable by some amount
• The modified assignment operators exist for all
  of the math operators.

aNum aNum 5 bNum bNum -10
cNum cNum 2 dNum dNum / 3 fNum fNum 12
aNum 5 bNum - 10
cNum 2 dNum / 3 fNum 12
29
Increment/Decrement operators

• We need to add/subtract 1 from numbers so often,
  they made a shortcut for each of the operations.
• is the increment operator, put it before or
  after a variable to increase its value by 1.
• -- is the decrement operator. Use just like the
  increment operator.

int aNum 3 aNum //now 4 aNum //now
5 --aNum //now 4 aNum-- //now 3
30
Before vs. After Increment/Decrement operators

• If you put the increment operator before the
  variable, then it will increment the variable
  before returning the value of the variable.
• If you put the increment operator after the
  variable, then the computer will first return the
  current value of the variable before
  incrementing.

int aNum 3 int bNum aNum //bNum is 3,
aNum is now 4. aNum 3 bNum aNum //bNum
and aNum are 4.
31
Precedence/Order of evaluations.

• Just like in math, there is an order in which we
  evaluate expressions.
• 345-8/4
• Parentheses override all natural precedence for
  the operators, so use parentheses when in doubt.
• A table of the precedence of all operators in
  Java is in Appendix 2 (page 991).

32
Strings
33
Strings are different

• Strings are not like the primitive types. They
  are objects created from a class
  (Object-oriented).
• Strings are long sequences or sentences of
  characters.
• Whenever we include something in quotation marks
  ( ,), Java considers it a String.
• We usually always are printing out Strings with
  the System.out.println command.

34
String Constants and Variables

• We can store any String constant into a String
  variable.
• We can then print out these variables to print
  out the string stored in them.

String Hello Howdy there!
System.out.println(Hello) //prints Howdy
there! to the screen.
35
String concatenation

• Concatenation is the act of gluing the beginning
  of one String onto the end of another.
• We can concatenate a String, variable, or object
  onto the end of any String by using the
  symbol.

String Hello Howdy Hello Hello there
//stores Howdy there int aNum 6 Hello
The number is aNum //stores the string
The number is 6. System.out.println(I see
5 birds) //prints out I see 5 birds
to the screen.
36
Comparing strings

• Since Strings are objects, we do not compare them
  in the same way that we compare regular
  variables.
• To compare two Strings we will have to use a
  method called equals.
• To use methods we follow the calling object (the
  first object we want to perform an action on, in
  this case a comparison) with a dot and the method
  name

String aString Howdy There. aString.equals(H
owdy) //returns false aString.equals(Howdy
There.) //returns true String bString
Hello bString.equals(aString) //returns false
37
Other String methods

• length()- returns the length of the String
• equalsIgnoreCase(AnotherString) returns true if
  the strings are equals without regards to the
  case of either.
• charAt(integer) returns the character located
  at the number indicated, given that the String
  starts at location 0.
• A full collection of String methods can be found
  in the book on pages 82-84 or on the web at
  www.java.sun.com

38
Escape characters

• To include certain characters in a String, we
  have to use an escape sequence.
• Placing the escape sequence inside of a String
  constant will cause the special character to show
  up when the String is printed out.

\ Double Quote \ Single Quote \\ Backslash \n
New line \r Carriage return \t Tab
Hello \t There prints out as Hello
There Hello \n There Hello There
39
Keyboard and Screen I/O
40
Screen Output

• System.out.println(someString) will output the
  String someString to the screen on its own line.
  It puts a new line character at the end of the
  String.
• System.out.print(someString) will output the
  String someString to the screen. No new line
  character will be added.

System.out.print(Hello ) System.out.println(Th
ere) System.out.println(Fred)
Hello There Fred
41
Keyboard input.

• Console input from a keyboard is a little
  difficult in Java.
• Dr. Savitch created his own input class to make
  things much, much easier on the beginning
  student. It is called SavitchIn.java.
• SavitchIn is not a part of standard Java, and you
  wont see it used outside of this class. We will
  see more on how to read input the hard way in
  Chapters 9 and 12.

42
SavitchIn methods.

• SavitchIn.readLineInt()
• SavitchIn.readLineLong()
• SavitchIn.readLineFloat()
• SavitchIn.readLineDouble()
• SavitchIn.readLineNonwhiteChar()
• SavitchIn.readLine()

43
Documentation
44
Self-documenting code

• You should write your code in such a manner that
  it almost documents itself.
• This means good variable name choice, good
  tabbing/indenting, and not being afraid to use
  some whitespace (spaces/empty lines, etc.)

45
Comment like crazy.

• Remember though your code may be obvious to you,
  it probably isnt to someone else.
• Comment whenever something may be misunderstood
  or confusing to someone else.

46
Review

• Comments
• Variables
• Expressions and operators
• Strings
• Keyboard and Screen I/O
• Documentation