Transcript lecture 4 intro_type method selection

Computer Numbers
• Integers (byte, short, int, long)
– whole numbers
– exact
– Relatively limited in magnitude (~1019)
• Floating Point (float, double)
– fractional
– often approximations (0.33333)
– larger magnitude (~10308)
– Actually hold signed mantissa & exponent
• 6.023 x 1023
List of Data Types
Primitive Type
Default Value
boolean
char
byte
short
int
long
float
double
void
false
'\u0000' (null)
(byte) 0
(short) 0
0
0L
0f
0d
N/A
Note: At times, the Java Language Specification refers to void as a primitive,
though other parts (e.g., s. 14.7) say ‘void’ is not a primitive as in C/C++.
One cannot cast to a void type in Java.
Data Type Ranges
Type
Size Min
false*
Max
Default
true*
false
boolean
1
char
16
byte
8
-128
127
(byte) 0
short
16
-32,768
32,767
(short) 0
int
32
-2,147,483,648
2,147,483,647
0
long
64
-9,223,372,036,854,775,808
9,223,372,036,854,775,807
0L
float
32
Approx
±3.4E+38 with 7 significant digits
0.0F
double
64
Approx
±1.7E+308 with 15 significant digits
0.0D
'\u0000' (null)
void
* Not truly min and max.
Understanding Casting
Last class, we covered some basics of casting.
Sometimes an explicit cast is required, sometimes it’s not.
OK!
Compiles
int x = 10;
float f1 = x;
ERROR
Explicit cast needed
float f2 = 11.234f;
int y = f2;
Which one requires a cast to compile? Why?
Understanding Casting
To understand when we need casting, let’s look
closely at an example.
Let’s work with these two types and identifiers:
int x;
char c;
The real question is,
How BIG are these data types in memory?
Recall
We already discussed the sizes of various data types in Java. You
are guaranteed to have four bytes in each and every int. We can
think of an int as a container--much like a box.
Cereal(tahıl) box
Nutritional Facts
Serv. Size 1 int
Amount per Serving
Calories 0
% Daily Value
Total Bytes 4
100%
And recall...
A char on the other hand is only 2 bytes.
It’s smaller than an int.
We might imagine it as a smaller container.
tuna
(ton balığı or orkinos)
can
Nutritional Facts
Serv. Size 1 char
Amount per Serving
Calories 0
% Daily Value
java char
Total Bytes 2
50%
So...
A char is 2 bytes, and an int is 4 bytes. So when we
code the following:
int x;
char c;
We get:
Symbol
Picture of Memory
x
0000 0000 0000 0000 0000 0000 0101 0110
c
0000 0000 0100 0001
Each block is
one byte
Reality Check
Will a can of tuna fit into a box of cereal?
Yes, the can is smaller.
Will a box of cereal fit into
a can of tuna? Not neatly,
the box is larger.
java char
In a similar vein...
Will a char fit into an int?
Will an int fit into a char?
Symbol
x
c
Picture of Memory
Reality Check
What if you wanted to fit HALF the box into the
can. That would fit!
For example, if we know the
top half of the box is empty,
we can throw it away!
java char
Explicit Casting: Intentional
Loss of Precision
int x = 45;
char c = ‘A’;
c = (char) x;
Symbol
// cast needed
Picture of Memory
x
c
cast needed!
Testing Yourself
Fill in the blank.
What happens when we do this:
int someInt = 2000;
long longNumber;
longNumber = (long) someInt;
Is that cast legal?
Is that cast required?
Another Example
float f;
int i, j;
i = 9;
j = 2;
f = i / j;
Returns 4 because
of integer truncation!
If that is not what was intended,
Three possible solutions
f = (float) i / j;
f = i / (float)j;
f = (float) i / (float) j;
Another example
We also have to consider how Java preserves the sign of
a value through casting. Consider the eight bytes used
for an int. The highest bit is used for a sign (plus or
minus, through a 0 or 1).
int
Sign
bit
31 bits
for data
Casting and Sign
Casting is not merely chopping one data type into
another. The VM doesn’t merely throw away half of
the information. The sign is preserved.
byte
Preserves
sign
bit
int
Another Example
Suppose we had some very, very old data, where the
date was expressed in a “int” (four byte) format, such
as:
19291031
1929
10
31
(October)
This is very crude, but some old data source (e.g.,
tape archives) might have this format.
public class CutData {
public static void main(String[] args) {
int iDate = 20001225;
// this is how it was read in
byte byDay = (byte) (iDate % 100);
System.out.println ("The day was " + byDay);
iDate = iDate / 100;
byte byMonth = (byte) (iDate % 100);
System.out.println ("The month was " + byMonth);
iDate = iDate / 100;
Explicit Cast needed
short sYear = (short) iDate;
System.out.print ("The year was = " + sYear);
}
} // CutData
When working in the opposite direction (accumulating
bytes and shorts into an int), no casting is needed,
because we do not lose precision or information.
public class PackDate {
public static void main(String[] args) {
byte month =
12;
byte day
=
25;
short year = 2000;
int date =
year
* 10000 +
month *
100 +
day;
System.out.println ("The date = " + date);
}
} // PackDate
Casting: Test Your Knowledge
• Given:
int start = 10;
float temp = 5.5f;
temp = (int) temp * start;
• What does temp now hold?
• Given:
char c = ‘A’;
int x;
c = x;
• Legal?
Quick
Review
Test Your Knowledge
• Here’s the problem:
int iVar = 10;
float fVar = 23.26f;
3
iVar = iVar * (int) fVar
// gives compile-time error
iVar = iVar * fVar
• Which solution works best?
230
4
1
iVar = (int) (iVar * fVar)
232
2
iVar = (int) iVar * fVar
Same Compile Error
iVar = (int)
((float) iVar * fVar)
232
Quick
Review
Shorthand Operators
•
•
•
•
counter = counter + 1;
counter = counter - 1;
counter = counter + 2;
counter = counter * 5;
OR counter++;
OR counter--;
OR counter+=2;
OR counter*=5;
Last two examples: perform operation
first (eg. counter+2) then performs the
assignment.
Understand this, but please avoid
these types of expressions.
Quick
Review
The Short End of Shorthand
Be careful to avoid ‘clever’ expressions with shorthand
notations.
For example, we can declare a variable called “_”. (Yes, and
underline character alone is a valid name.)
int _ = 1;
We can then use a combination of operators to make Morse
code:
_ -= --_ - _--;
Yes, this is valid; however, it’s completely unreadable.
(Your replacement will not appreciate this style!)
Documentation & Comments
• Three ways to do it:
Quick
Review
// comments out everything until the end of the line
/* comments out everything until the */
(There are no nested comments as in C++.)
/**
* This is syntax for Javadoc comments (similar to second style
* of commenting, but allows for HTML formatting features.
*/
•
For CS1302, use Javadoc comments
Let’s work a
javadoc example
Javadoc: Simple Example
import java.util.*;
Javadoc comments
/**
must appear above
* HelloComments.java
the item they
*
*
modify.
* Created: Wed Jan 12 18:17:29 2000
*
In the case of class
* @author David Dagon
comments, place
* @version 98 beta
them BELOW the
*/
public class HelloComments {
import statements.
/**
* A <b> VERY </b> simple variable.
*/
public int x = 10;
Recall:
HTML is OK!
Simple Example (cont’d)
/**
* This comment is reproduced twice, because
* of the comma delimited declaration of ints.
* The solution would be to use separate lines
* for each declaration.
*/
Short, one-liner,
public int y = 4, z = 11;
followed by period
/**
* The Main method. This method is the starting
* point of this program, when this class is run.
*
* @param args The arguments from the command line.
*/
public static void main(String[] args) {
}
} // HelloComments
Just give the variable
name; no dashes, etc.
Javadoc (Cont’d)
• You may include HTML tags (but avoid structuring tags, like <H1>,
etc.)
• Javadoc comments should immediately preceed the declaration of
the class, field or method. The first sentence should be a
summary. Use the special javadoc tags--@. When '@' tags are
used, the parsing continues until the doc compiler encounters the
next '@' tag.
@see <class name>
@see <full-class name>
@see <full-class
name#method.name>
@version
@author
@param
@return
@exception
@deprecated
@since
@serial
// jdk 1.1
// jdk 1.1
// jdk 1.2
You might
refer back
to these
notes once
you start
writing your
own javadoc
comments.
Questions?
Constants
• Java:
Quick
Review
– public final static <type> <IDer> = <value>;
– public final static int MIN_PASSING = 60;
– public final static float PI = 3.14159f;
• Details on “why this syntax” to come soon...
Printing to Screen
• Java:
–
–
–
–
Quick
Review
System.out.println(<argument>);
System.out.println( ); // prints blank line
System.out.println(5); // prints 5
System.out.println(“Hello World”); // prints Hello
World
– “println” vs. “print” in Java:
• println includes “carriage return” at end,
hence the next print or println starts new line
• print – not carriage return included.
causes next print or println to begin on same line
Method
Madness
Caution
Before we can talk about methods in Java, we need
to look at programming languages in general, from
a very high level.
Don’t be alarmed by some of the syntax on the
following slides. The big picture is what’s
important, not the coding details....
Programming Paradigms
Procedural Programming
‘Imperative’ assignment used to create state, and
procedures manipulate state. E.g., C, Assembly, Pascal
int y; int x = 3;
y = manipulateData(x);
Functional Programming
Functions (procedures that do not depend on outside
data) are used to provided data. E.g., Lisp.
(defun check-member (input-item input-list)
(cond ((null input-list) nil)
((equal input-item (first input-list)) T)
(T (check-member input-item (rest input-list)))))
Programming Paradigms
Object-Oriented Programming
All data exists in objects; interaction occurs only between
objects. Even numbers are objects that know how to add
themselves. E.g., SmallTalk:
| array |
array := Array new: 5.
rect := 0@0 corner: 8@9.
1 to: array size do: [ :item |
rect origin: item@item.
array at: item put: rect copy ].
There are other
paradigms, but
these three help
explain where
Java comes from
Where does Java fit?
Object-oriented, but not 100% OO, since it contains
primitives, and tolerates some (hopefully small) degree of
procedural programming.
Java Methods
There exists in Java a single construct, the method, for
both procedures and functions:
• when a procedure is called for, specify
the return type “void” before method name
public void printHelloWorld( )
{
System.out.println(“Hello World!”);
} // printHelloWorld
Note the comment
• Note: All methods must have parentheses
for parameters . . . even if no parameters!
Java Methods
Single construct (method) for both procedures and
functions:
• when a function is called for, specify the
appropriate return type before method name
public float average (float num1, float num2, float num3)
{
float answer;
answer =
(num1 + num2 + num3)/ 3;
return (answer);
} // of average
Writing Methods: A Larger Look
A Java requirement:
--Each method belongs to an object (or class).
--It must be unambiguous which object or class that
is when a method called.
--To run an application program, there must
be a class whose name is that of the program
for command
and that class must have a method
line parameters
called main:
visible
to all
nothing
returned
public static void main (String[ ] argv)
a class
method,
not an
instance
method
Method name
class A
{
public static void main(...
}
class B
{
public static void main(...
}
class C
{
public static void main(...
}
Thus, each class
may have it’s own
main method. You
pick the one you
wish to run when
invoking the JVM.
This fact becomes
critical when we
learn to write
debug test mains.
Method Signatures
“The signature of a method consists of the name of the
method and the number and types of formal parameters
to the method. A class may not declare two methods
with the same signature, or a compile time error occurs.”
--Java Language Specification s.8.4.2
Method overloading occurs where identically named methods have
subtle variations in the method parameters.
public int getCube(int num){
return num*num*num;
}
public int getCube(float num){
return (int)(num*num*num);
}
public int getCube(double num){
return (int) (num*num*num);
}
Java lets you
overload
instead.
Methods: Common Mistakes
public float average (float num1, float num2, float num3);
{
float answer;
answer =
(num1 + num2 + num3)/ 3;
return (answer);
} // average
Note ending semicolon
-- could be viewed as ‘abstract’ method
(more on abstract methods later)
-- results in unhelpful error message about
abstract methods (more on this later)
-- EASY mistake to make!
Where do Methods Go?
Just like the main method we saw last time, any method we
create must appear in classes, as either “class” or
“instance” members. More on creating classes and
objects shortly . . .
For now, just know that methods belong in a class.
i.e. They are defined inside a class.
OO Programming Note
Already, we’ve covered one of the most important aspects
of Object Oriented (OO) programming:
Data and methods belong together in a class.
Right now, it’s sufficient that you merely know that
variables and methods belong in classes.
Later, we’ll see how this enables us to encapsulate state
(the variables) with behavior (the methods).
So, remember this day. You’ve started to learn THE
cornerstone of OO programming.
Questions?
Conditionals
Decision Statements
• Java:
if (condition)
single statement;
else
single statement;
• or:
if (condition)
{
statements;
}
else
{
statements;
}
Examples
• Java: What happens here?
int testGrade = 65;
boolean passing = true;
if (testGrade < 60)
passing = false;
System.out.println(“Is “ + testGrade +
“passing? “
+passing);
Boolean and
Relational Operators
• Boolean:
AND
OR
NOT
Java:
&&
||
!
• Relational:
equal to
not equal to
less than
less than or equal to
greater than
greater than or equal to
==
!=
<
<=
>
>=
• Note:
Assignment
=
Example
if (enrolled && passing) {
// etc.
}
Java also supports short-circuiting, where only part of
a boolean will be evaluated, as necessary:
if (enrolled(studentNum) ||
getPassing(studentNum)) {
// etc.
}
A bit o’ code
public static void main(String args[]) {
int quiz1 = 42;
int quiz2 = 99;
if(isPassing(quiz1) && isPassing(quiz2))
System.out.println(“Passed both quizzes”);
}
public static boolean isPassing(int testGrade) {
boolean passing = true;
if (testGrade < 60)
passing = false;
System.out.println(“Is “ + testGrade +
“ passing? “ + passing);
return passing;
}
Final Answer?
Is 42 passing? false
Is 42 passing? false
Is 99 passing? true
a
b
Multiple Selections via switch
Use if construct for one selection.
Use if/else construct for double selection.
Use switch construct for multiple selection.
(e.g., situations appropriate for if-elseif-elseif-else)
Note:
• Useful when making a selection among
multiple values of the same variable.
• Not useful when selecting among values
of different variables.
Switch
switch (<variable>)
{
case <value>:
// whatever code you want
break; // optional
case <value>:
// whatever code you want
break; // optional
default:
// whatever code you want
break; // optional
}
Multiple Selections via switch
Note the “optional” default case at the end of the switch statement.
It is optional only in terms of syntax.
switch (iNumber) {
case 1:
This would
System.out.println (“One”);
work without
break;
the default,
case 2:
but would
System.out.println (“Two”);
be poor
break;
technique
case 3:
System.out.println (“Three”);
break;
default:
System.out.println(“Not 1, 2, or 3”);
break; // Needed???
} // switch
In practice you should always include a ‘default’ case statement.
How many days?
if(month == 4 || month == 6 ||
month == 9 || month == 11)
numdays = 30;
else if(month == 2)
{
numdays = 28;
if(leap)
numdays = 29;
}
else
numdays = 31;
Switch
switch (month)
{
case 4:
case 6:
case 9:
case 11:
numdays = 30;
break;
case 2:
numdays = 28;
if(leap)
numdays = 29;
break;
default:
/* Good idea? */
numdays = 31;
}
Multiple Selections via switch--Notes
• The switch statement can only be used with
the following types:
int, char, short & byte
(You can cast floats, doubles, etc.)
• The case values must all be of the same type.
• The case values must all be FINAL constants.
switch (grade) {
case ‘A’: case ‘a’:
countOfAGrades++;
if (grade==‘A’ || grade==‘a’)
break;
countOfAGrades++;
case ‘B’: case ‘b’:
else if (grade==‘B’ || grade==‘b’)
countOfBGrades++;
countOfBGrades++;
break;
else if (grade==‘C’ || grade==‘c’)
case ‘C’: case ‘c’:
countOfCGrades++;
same
countOfCGrades++;
else if (grade==‘D’ || grade==‘d’)
break;
countOfDGrades++;
case ‘D’: case ‘d’:
else if (grade==‘F’ || grade==‘f’)
countOfDGrades++;
countOfFGrades++;
break;
else
case ‘F’: case ‘f’:
System.out.println
countOfFGrades++;
(“Invalid grade”);
break;
default:
System.out.println(“Invalid grade”);
(assume these variables
break;
exist and have value)
}
Multiple Selections via switch
Before we go too far...
• We often take liberties with good coding
practice just to fit material onto a slide.
• Your coding style should reflect clearly
and unambiguously what the code is
supposed to do.
• Keep in mind your two audiences
– The machine
– Other programmers
If
Style 1
if(<boolean expression>)
{
// code if true
}
else
{
// code if false
}
If
Style 2
if(<boolean expression>) {
// code if true
} // comment
else {
// code if false
} // comment
Conditional Assignment
boolean b;
int count;
<boolean> ? <true condition>
: <false condition>
b = checkCompletion();
count = (b) ? 3 : 1;
Must resolve
to boolean
Note:
This is not any faster.
It’s less readable.
If true . . .
. . . if false
It exists only for
‘recovering C
hackers’
A Semi Partial
Conditional Summary
• Control structures
–Two kinds of conditional
(summary)
• if { ... } else { ... }
– branch on boolean expression
• switch (...) { case ...; break; default: ... }
– branch on constant value
– don’t forget to break !!
Questions?