Prepared by: Ivor Baatjes and Tsakani Chaka (Supported by ...
Lecture 5 Instructor: Craig Duckett “Ooga-Chaka Ooga-Ooga”
-
Upload
linda-gaines -
Category
Documents
-
view
233 -
download
1
Transcript of Lecture 5 Instructor: Craig Duckett “Ooga-Chaka Ooga-Ooga”
BIT115: Introduction to Programming
Lecture 5 Instructor: Craig Duckett
“Ooga-Chaka Ooga-Ooga”
Assignment 1
Assignment 1 Due TONIGHT
Uploaded to StudentTracker by midnight Tuesday, October 13th I will double dog dare try to have Assignment 1 graded and returned by Friday, October 16th (hopefully sooner)
PLEASE NOTE: if, for some reason, StudentTracker is not up when you go to submit your Assignments, wait a few minutes in try again. If you still cannot access StudentTracker, then please attach your zipped Assignment to an email and send to me!
3
• Assignment 1 (LECTURE 5) Tuesday, October 13 in StudentTracker by midnight• Assignment 2 (LECTURE 8)
Thursday, October 22• Assignment 1 Revision (LECTURE 10)
Tuesday, November 3• Assignment 2 Revision (LECTURE 12)
Tuesday, November 10• Assignment 3 (LECTURE 13)
Thursday, November 12• Assignment 3 Revision (LECTURE 16)
Tuesday, November 24• Assignment 4 (LECTURE 20)
Tuesday, December 8• Assignment 4 Revision (LECTURE 21)
Thursday, December 10
Assignment Dates (By Due Date)
A Note About EmailI've set up a proprietary [email protected] account specifically for returning graded files from StudentTracker. Depending on your email account (like gmail), you may getting a warning similar to this:
This email is indeed coming from me, and can be safely ignored.
PLEASE NOTE: If you need to contact me please do not reply to the gmail message from StudentTracker, but write to me instead using my college [email protected] email account address. As I explained, this gmail account is a proprietary account I set up solely for sending assignments to and from StudentTracker and I only check it for email messages a couple of times a month.
So: if you have a question or comment about BIT115 or your assignments, and you would prefer getting a timely reply, please contact me using my Cascadia email, or you may be waiting for a long long loooong while before receiving an answer. Thanks!
Lecture 5 AnnouncementsWhat We Will Be Going Over Today
Appendix F.4 – Temporary Memory• Variables (Brief Introduction)
• We will be going over variables in much greater detail after the Mid-Term• Data Types• How Declaring a Data Type is Stored in Memory• How Binary Numbers represent the Storing of that Data in memory
• STARTING WITH LECTURE 4, I will be posting SOLUTIONS for the ICES. Remember, the solutions will vary depending on the developer, so these are my solutions—your solutions may look a bit different. These have been provided for reference, and to help you overt a hurdle in case you get stuck. It’s okay to use them
Mid-Term (A Head's Up)Mid-Term scheduled for Lecture 9 Thursday, October 29th TWO WEEKS FROM THIS THURSDAY
• It will cover everything learned up through Lecture 7 (“Output”)
• It is scheduled for the entire session, so you will have more than enough time to work through each of the questions.
• When you are finished, you can hand it in and you are done for the day, so feel free to go home or the nearest pub for a celebratory pint or two ;-)
• It will be done entirely with pencil-and-paper (no .java files).
• A Mid-Term Review File is available for downloading on the BIT115 web site in a box in the right-hand column
Mid-Term, continued…Mid-Term is scheduled for LECTURE 9 (Thursday, October 29th)
The Mid-Term Exam will focus on three learning outcomes:• conceptualize the logical steps needed to accomplish a task, • apply structured programming techniques to accomplish a task, • test and debug a program
Exam Topics:• Setting up a city with walls, things, robots • Using the robots built-in services • Extending a robot to include new services • Tracing code and pinpointing where it goes wrong • Explaining the compile/run process • Selecting when to use different programming structures like loops, decisions, and services • Writing syntax for loops, decisions, local variables, and parameters
Again, the exam will be similar to the quiz format (i.e., pencil-paper, from memory, individual work).
And Now… The Quiz
While Loops RefreshAs we shall soon see, while loops are commonly used for counting and implementing counters inside of programs
But before we go forward to see how counting and counters work, let’s refresh our memories by doing a few In-Class Exercises so we can get a feel again how while loops work.
Please go to to programajama.com Lecture 4 and follow the In-Class Exercises Directions under While Loops (Repeating Statements). We will be doing one trace table which you can download by looking under Course Wide Information near the top of the page, then finding Blank Documents and grabbing Program Trace Table.
While(<<BooleanExpression>>){ <<statement>>}
While(<<BooleanExpression>>){ <<statement>> <<statement>> <<statement>>}
While Loops
BIT 115: Introduction To Programming 10
This can produce an
“Infinite Loop” (Hangs/Crashes)
Only wanted to mention these here
so you will be watchful. We will
go over while loops in greater detail in
another lecture.
BIT 115: Introduction To Programming 11
Memory Video
Temporary Memory, Variables
Data Types
A data type is nothing but the type of the data that will be stored in memory.
Different data types require smaller or larger amounts of storage capacity, so when you declare a data type you are telling the program upfront the size of the storage container you want to set aside in memory.
Example by Analogy: If you want to store a quart of water, then you need a container that will hold a quart. If you want to store a gallon of water, then you need a container that will hold a gallon. In both cases, you need the container before you can put the water in it. Declaring a data type is getting the container ready before you put anything in it—first the container, then what goes into it.
Appendix F.4 – Temporary Memory Chapter 5.2 – Temporary Variables (Local Variables)
byte short int long
Temporary Memory, Variables
byte short int long
1 by
te
4 by
te
2 by
te
8 by
te
float double
Temporary Memory, Variables
Data Types
A variable in Java must have certain type associated with it which tells us what kind of data a variable can store, and whether that storage requires a small “container” in memory or a larger “container” (i.e., number of bits making up the storage space).
Data Types in the Java Programming Language are classified into two main groups:
• Primitive Data Types• We will discuss Primitive Data Types now
• Referential Data Types• We will discuss Reference Data Types later in the Quarter
int num = 0;int numThings = 5;int numStuff = 10;
// int – gets the container ready// num – tells which container to use// 0 – integer that is put into the container
num
numThings
int
int
numStuff
int
0
5
10
"Primitive" Data Types• Why the term "primitive"?• "Primitive" just means an actual number is actually
contained in that actual memory location.
Primitive Not Primitive"Referential"
Data isover there
1212
"Primitive" Data Types
byte short int long float double boolean char
• Primitive data types are built into the Java language and are not derived from classes.
• There are eight (8) "primitive" data types in Java.
Integer (-128 to 127)Integer (-32,768 to 32,767)Integer (-2,147,483,648 to 2,147,483,647) billionInteger (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)*Decimal (±1.4E-45 to ±3.4028235E+38)Decimal (±4.9E-324 to ±1.7976931348623157E+308)True or FalseUnicode character value, like 'A' or '$' or '#' or '*'
1-byte (8 bits)2-bytes (16 bits)4-bytes (32 bits)8-bytes (64 bits)4-bytes (32 bits)8-bytes (64 bits)1 bit ( 1 or 0)2-bytes (16 bits)
*quintillion
int num = 125;int numThings = 30000;int numStuff = 1000000;
125
30,000
1,000,000
byte -128 to 127 Short -32,768 to 32,767 Int -2,147,483,648 to 2,147,483,647 long -9 quintillion to 9 quintillion
byte num = 125;byte numThings = 30000;byte numStuff = 1000000;
short num = 125;short numThings = 30000;short numStuff = 1000000;
long num = 125;long numThings = 30000;long numStuff = 1000000;
Declaring a Data Type Sets Memory Size
NOTE: The Next Nine (9) Slides are for "Informational Purposes Only"
(They are NOT going to be on a Test!)
Example of Exponential Notation
1.4E-45 means 1.4*10^-45 (E stands for "exponent")0.000000000000000000000000000000000000000000014This is the smallest possible positive float number
3.4E+38 means3.4*10^38340,000,000,000,000,000,000,000,000,000,000,000,000This represents the largest possible postive float number
Remember that there are also negative float numbers (or "signed" numbers)
Binary (A Quick Look)
128 64 32 16 8 4 2 1
Byte (8 Bits)
8 7 6 5 4 3 2 1
A byte is a collection of eight memory cells called "binary elements" or "bits" for short
The content of a byte is determined for calculation from right to left. So the first bit in a back is on the far right, and the last bit in a byte is on the far left.
Going from right to left, the first column represents a 1 when turned on, the second represents a 2, the third represents a 4, the fourth represents an 8, and so on.
Binary128 64 32 16 8 4 2 1
0 0 0 0 0 0 0 0 0
0 0 0 1 0 1 0 1
1 1 0 1 1 0 0 0
0 0 0 0 1 1 1 1
0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
21
216
15
127
255
Byte (8 Bits) UNSIGNED
A bit that is "turned off" is represented by a 0. A bit that is "turned on" is represented by a 1.
Primitive Data Types are "Signed"The eight (8) "primitive" data types in Java are "signed" by default. This means by default they represent a range from a negative number, using the minus "sign" - , to a positive number. So the term "signed" represents this negative to positive range.
byte short int long float double boolean char
Integer (-128 to 127)Integer (-32,768 to 32,767)Integer (-2,147,483,648 to 2,147,483,647)Integer (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)Decimal (±1.4E-45 to ±3.4028235E+38)Decimal (±4.9E-324 to ±1.7976931348623157E+308)True or FalseUnicode character value, like 'A' or '$' or '#' or '*'
Primitive Data TypesWHAT DOES “SIGNED” or "UNSIGNED" MEAN?
“Signed” means it contains values equally split between positive and negative numbers, and “Unsigned” means that that same number of values can only be positive, starting a zero and getting larger
The “sign” in this case means the integer values can have a ‘minus sign’ (-), and “unsigned” means ‘no minus sign’
For example:• A ‘signed’ byte has a range of -128 to 127• An ‘unsigned’ byte has a range of 0 to 255
NOTE: Earlier versions of Java did NOT support "unsigned" integer data types; all integer data types were "signed" which meant they represent this negative to positive range. Now, even though Java 8 does allow for "unsigned" data types there is no way to declare an unsigned type up front. You can only manipulate unsigned data into being from a method.
Signed vs. Unsigned
128 64 32 16 8 4 2 1
255
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0
"Two's Complement"
Byte (Unsigned)
But because a byte is defined as an 8-bit number in the range of -128 to 127 how would you express, for example, -5? You do it using a computer trick called "Two's Complement". First you represent +5 in binary, then you invert the binary, negate the last number, then add 1.
0 0 0 0 0 1 0 1
1 1 1 1 1 0 1 0
5
-128 64 32 16 8 0 2 1
+1
-128 + 123 (or 64+32+16+8+2+1) = -5
128 64 32 16 8 4 2 1 byte 1
32768 16384 8192 4096 2048 1024 512 256
8388608 4194304 2097152 1048576 524288 262144 131072 65536
2147483648
1073741824
536870912
268435456
134217728
67108864
33554432
16777216
An int (integer) is 4-bytes:
-2,147,483,648 to 2,147,483,647 (Signed) 4264967295 (Unsigned)
byte 2
byte 3
byte 4
byte
short
int
long
float
double
boolean
char
Primitive Data Types So, when you explicitly declare a data type you are setting up a collection of binary elements in memory large enough to hold a number within a particular range determined by that number of binary elements (bits).
Primitive Data Types: Rangebyte 1 byte
8 bitsIntegers in the range-128 to +127
short 2 bytes16 bits
Integers in the range of-32,768 to +32,767
int 4 bytes32bits
Integers in the range of-2,147,483,648 to +2,147,483,647
long 8 bytes64 bits
Integers in the range of-9,223,372,036,854,775,808 to +9,223,372,036,854,775,807
float 4 bytes32 bits
Floating-point numbers in the range of ±3.410-38 to ±3.41038, with 7 digits of accuracy
double 8 bytes64 bits
Floating-point numbers in the range of ±1.710-308 to ±1.710308, with 15 digits of accuracy
DeclarationsDeclarations with initializations (assigning an "initial" value) take
the following form:DataType DataName = DataValue;
byte inches = 32; short month = 12; int speed = 60; long timestamp = 24.00; float salesCommission = 100.00; double distance = 92960000.00; boolean user = true; char ch1 = 'A'; // or unicode: char ch1 = 65;
Integer Data Typesbyte, short, int, and long are all integer data types.They can hold whole numbers such as 5, 10, 23, 6789,
etc. Integer data types can not hold numbers that have a
decimal point in them. Integers embedded into Java source code are called
integer literals. "Literal" is programming-speak meaning "What you type is what you get" or "the data is literally there."
For example, if in my code I declare an integer with the name someNumber and initialize with the number 100, then I am literally putting the number 100 in a memory location called someNumber.
int someNumber = 100;someNumber
100
Floating-Point Data Typesfloat and double are floating-point data types.
They hold decimal-point numbers such as 1.5, 123.456, etc.
If you initialize a float or double with a single number, it will display that number with a decimal point followed by a zero, for example:
float num = 1; will output 1.0
The data type double is shorthand for double-precision, and does not mean you are "doubling" a number. It just means you can hold a much larger and more precise decimal-point number.
Don't get confused with the term 'double'…it does not mean 'double it'.
5
32
FYI (Just for Fun)If you want to give the Robot a label when the program runs, then you will have to do something like this:
mary.setLabel("Mary");
If you want to change the Robot's color, then you will have to include this at the top of your file
import java.awt.Color;
And then do something like this:
mary.setColor(Color.ORANGE);
Also, if you want to change the color of a wall, first give the wall a name, then color it according to that name:
Wall w1 = new Wall(bothell,2,1,Direction.NORTH); w1.setColor(Color.BLUE); Wall w2 = new Wall(bothell,2,2,Direction.NORTH); w2.setColor(Color.GREEN);