cs 5ja introduction to java last class... we gave a definition of high-level vs. low-level. we...

CS 5JA Introduction to Java

Last class...We gave a definition of high-level vs. low-level. We talked about what object-oriented means.

We gave a broad overview of about how software is a set of precise instructions and also a way to model aspects or features of a problem or a system.

Hopefully by now we have all installed the JDK and can compile and execute our code!

Today we are going to start diving into how we give instructions to the computer. In particular, we will look at how we can define and manipulate data using variables.

At the end of class we will look at a small program together.


The turn-in webpage...But first...

You can find the link to the Turn-in website from the homework.


What is a variable?A variable is an address or an index to some place in the computers memory which holds data.

It's called a variable because it can be changed.

Each variable has a name and a type.

The variable is always referred to by its name.


An example of a variable...int myNumber;

You are declaring the variable named "myNumber" of type int (integer). That is, a whole number.

You can then assign a specific integer to your variable. It's like having a bucket, and adding a label to it. Then you put something inside it.

myNumber = 9;

What this is saying is: Put the integer 9 into the bucket labeled “myNumber".


Assigning data to a variableBut it's a very fragile bucket. And if you put anything else into it besides a whole number, it will break, and your program will not run. For instance :

myNumber = 9.5; //Error!

This doesn’t work because we are trying to put a decimal number into a bucket of type integer. The bucket labeled “myNumber” is expecting an integer. Nothing else will fit into that bucket.

Even though the bucket is labeled “myNumber”, the name has no actual meaning.

For example if you make a bucket of type int but call it “myDecimalNumber”, it still can only accept integer numbers!


Assigning data to a variablePutting data into a bucket is called variable assignment. You assign data to a variable by using the = sign. For all practical purposes, the label on the bucket equals the data inside the bucket.

myNumber = 123;

When you see the equals sign in a statement like this, it helps to say out loud to yourself: I am putting the number 123 into the integer variable called “myNumber”.

What does this do?

int myNumber;myNumber = 123;myNumber = 321;


Assigning data to a variableIf you assign new data to a variable, you destroy the data that was already in there. In the above example, the first line creates an integer bucket. The second line puts the number 123 into the bucket. The third line puts the number 321 into the bucket and completely destroys whatever was in there before.

You can think of it like this: When you first create the variable, there is a little blackboard in the bucket. When you assign data to the variable, you are taking out the blackboard, erasing whatever is on it, and writing the new data on the blackboard, then putting it back in the bucket.

You can also create the variable and assign data to it at the same time:

int myNumber = 1001; //both creates and assigns


OperationsCertain activities are so fundamental that they are built right into the language and have their own symbols. These symbols are called operators. Here are some mathematical operators: +, -, *, /, %, ++, = that work on data in integer buckets (variables of type int).

For example, if we want to add two numbers together we can use the addition operator.

int x = 5;

int y = 6;

int z = x + y; //Now what is in the z bucket?


Operations on variablesint x = 5;int y = 6;int z = x + y; Now z contains the number 11.

In the third line we did is the following: took a number out of the integer bucket x, took another number out of the integer bucket y and then gave them to the CPU and told it to add those two numbers together. Then we took that number and put it inside of the bucket z.

Try this:int x = 5;int y = 6 + x;int z = x * y; //What number is assigned to z?


Operations on variablesint x = 5;

int y = 6 + x;

int z = x * y; //What number is assigned to z?

After the second line, y contains the number 11, and x still contains the number 5. So at the third line we take the number 5 out of x and 11 out y and tell the CPU to multiply them together. We put the result into z. Since 5 times 11 equals 55, z now contains the number 55.


Types of variablesYou can make buckets of any type you want! There are some data types that are so common that we refer to them as primitive types. These are the 8 primitive types:

Whole numbersint (32-bit), short (16-bit), long (64-bit), char (16-bit, positive only), byte (8-bit)

Decimal numbersdouble (32-bit), float (64-bit)

Logical boolean (1-bit, true or false)

(http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html)


What is a bit?A bit is a the smallest possible piece of information. It is either ON or OFF, a 1 or a 0. You can build larger pieces of information from a series of bits.

For example, you can build a binary number from a series of bits. if you have two bits then there are 4 possible permutations, so you can represents 4 numbers with 2 bits, the numbers 0, 1, 2, and 3.

00 = the number 0

01 = the number 1

10 = the number 2

11 = the number 3


Binary numbersThe first column from the end tells you if you should add a 1 to your number.The next column to the left tells you if you should add a 2 to your number.

So if the binary number is “01”: The first column is OFF, so we do not add a 1. But the second column is ON, so we do add a 2. Thus the binary number “01” equals the number 2

Each successive column tells you if you should add 2^n to your number. For example if you have a number that is 4-bits long then the first column is 2^0 or 1, the second is 2^1 or 2, the third is 2^2 or 4, the fourth is 2^3 or 8, etc. With a 4-bit number you count from 0 up to 1+2+4+8 or 15 for a total of 2^4 or 16 numbers.

(You’ll notice that first = 0, second = 1, etc. This is very common in programming. We start counting at 0 instead of 1. Usually.)


What number is this?How many bits does this number have?

What is the highest number we can represent with this many bits?

8 4 2 1

ON ON OFF ON


Binary numbersIf an int is represented with 32 bits, then what is the maximum number a variable of type int can point to?

2^32 = 4,294,967,296 numbers, and since we include zero, we can count from 0 through 4,294,967,295. However, one bit is used to determine whether it is negative or positive number, so we can actually represent -2,147,483,648 through +2,147,483,647. So what happens here? int myNumber = 2,147,483,648; //???

If you are curious read Appendix E in the book. Also:http://en.wikipedia.org/wiki/Binary_numeral_systemhttp://en.wikipedia.org/wiki/Two's_complement


Examples of other primitive variablesdouble myDecimal = 1043.13299843;

boolean myTruthValue = true;

char myLetter = ‘J’;

What happens if you do this?

double myNumber = 10; //automatic translation to 10.0

int myNumber = 10.5; //Possible loss of precision!

int myLetter = ‘b’; //Huh?


Other non-primitive variablesYou can also have variables for more complicated types that you either use from the java library or that you build yourself. Any type that is not primitive is capitalized.

You make a new variable for your type just by writing:String myString;

And you put new data into your bucket with the new keyword:myString = new String(“I am a string!”);

Or, as before, you can make the bucket and put the data object into it at the same time.

String myWords = new String(“This is a string of letters...”);


The Scanner objectThe java library has tons of types already made for you. A very useful thing that you will probably want to do is let people type in something from the terminal window.

How do you get something you type into your program? You use the built in Scanner object. The Scanner waits for you to type something in, then when you press return it lets you examine what was typed in. Let’s make a bucket that holds a Scanner:

Scanner myScanner;

You now have a variable named myScanner which is able to hold a Scanner.

Let’s make a Scanner and put it in our bucket:myScanner = new Scanner(System.in);


The Scanner objectThe Scanner is not just a simple data type. It is an object. Last week we talked about how objects are models. The Scanner object models a machine which scans and processes a line of text in a book. Or which scans a barcode and processes the symbols it reads.

The line below creates a Scanner machine which reads input from the System (which by default is the keyboard) and then puts it in the bucket labelled myScanner.

Scanner myScanner = new Scanner(System.in);

You can then use this machine to scan a line of text.


The Scanner objectLet’s say we want to read a number from the line of text that a user types in.

We can pass an instruction to the Scanner machine by invoking one of the Scanner’s methods.

Methods are how you interact with the objects you create.

Here is how we instruct the our Scanner to read a number from a line of text:

myScanner.nextInt();


The Scanner objectThis method processes the text and returns the integer it found. We can make a bucket for this number just as we did before:

int userNumber;

userNumber = myScanner.nextInt();

In English:

Make an integer bucket called userNumber.

Take the Scanner out of the bucket called myScanner.

Tell the Scanner to wait for the user to enter text AND to then to scan for the first number in that text.

Put that number into the userNumber bucket.

We now have a variable that we can do something with! Hooray!


JavadocsA simple program which uses a Scanner to add two numbers together is on page 47 of your text book.

If you are curious you can look at the Javadocs and find out every method that exists. The Javadocs for a particular object contain all the methods you can use to pass instructions to that object. For instance, below is the link for the Scanner object:

http://java.sun.com/javase/6/docs/api/java/util/Scanner.html

And this is the link for all of the objects in the Java library:

http://java.sun.com/javase/6/docs/api/


A look ahead...In the future, we will make our own custom objects.

Once we do that, we can make a bucket to hold that object, and write functions to manipulate them.

For example we might create these objects:

BowlingBall myBlackBowlingBall = new BowlingBall(Color.BLACK);

Or

Alien mySpaceAlien = new Alien(“Zorgon”);

And then instruct them somehow:

myBlackBowlingBall.drop();

mySpaceAlien.fireWeaponAtNearestEnemy();


Let’s look at a program...


On Tuesday...Last class we talked about a few different things:

We talked about variables, how to create them and how to assign data to them. We also talked about how to create a variable and assign data to it at the same time.

We talked about different mathematical operators you could use with variables of type int. We talked about the 8 different primitive data types, and about how you can use other built-in non-primitive data types (or objects), or import them from the Java library, or create custom ones.

We looked closely at the Scanner object from the java.util library and looked at program that uses the Scanner object to add two numbers together.

We also took a brief tangent and looked at bits and binary numbers.


Today...We are going to talk about variables just a little bit more and also talk more about operators, including the order of operations for mathematical operators. Also we will introduce equality and relational operators.

We will look at a short program that makes use of the concepts we’ve introduced so far.

And we have a new homework assignment. The assignment will ask you to write a few short programs of your own.

That is, by the end of the homework you will be actual programmers!

Note: Your TAs are there to help... Feel free to go to any TAs office hours. They will also arrange to meet you at other times if they are too busy to help you. Ask “stupid” questions during discussion sections– If you don’t understand something then I guarantee that you are not alone.


Pop Quiz!Convert these three numbers from binary into decimal and write down how many bits are used to represent each number :

a. 1010b. 11001010c. 0000000000000001

Here is a short snippet from a program:int a = 15;int b = a / 3;int c = b * a;What are the values of a, b, and c after these three lines are executed?

What is the value of x after the following line has been executed?int x = 15.9;

Name the 8 primitive data types in Java. Which one is only 1-bit in size?


Variables, another view...Another way to think of variables is as data that occupies a space in memory.

You can think of the memory available to your program as a big empty field of 1s and 0s. When you make a variable you are building a fence around an area in that field.

If you use a primitive, then the size is always the same. If it’s a byte then you have a plot of land that is 8 bits big (representing the number -128 through 127). There is a fence around it with a sign that has the name of the variable.

byte myByte = 65;

1010101000011001

0100111001101000

101001000001010000011010

0011110011010011

fence around “myByte” farm

other data


Variables, another view...This is also one reason why we had that error when we tried to put a decimal into an int bucket.

The default decimal data type is a double. And a double needs to be represented with a farm with 64 plots of land, or bits. So when we try to put a 64 bits into an space in memory that only room for 32, the java compiler complains and will not run.

However, the opposite works just fine. You can put an int into a double without any errors, because there is enough room for it.

Changing one data type into another data type is called casting. We’ll encounter this again later...


Order of OperationsWhat else can we do with integers?

There are a number of fundamental mathematical operators. You can use them to build equations out of numbers of variables that have data types of whole or decimal numbers.

*, /, %, +, - stand for multiplication, division, modulo, plus and minus, respectively.

Just as in a mathematical equation, you evaluate multiplication and division before subtraction and addition. If you want to force a different order, you simply put them in parentheses. You can not use brackets as you would in an equation. Rather you use a as many parentheses as necessary.


Order of OperationsFor example, if you are making a variable to store the results of the following equation: int result = 5 + 7 * 4 - 6 / 3;

you first multiply 6 and 4, then divide 2 by 3, then perform the addition, then the subtraction. So,

after first operation : 5 + 28 – 6 / 3

after second operation : 5 + 28 – 2

after third operation : 33 – 2

after fourth operation : 31

Thus, the variable result contains the integer 31.

To make things clearer you can also write your equations with paretheses:

int result = 5 + (7 * 4) – (6 / 3); //also = 31


Order of OperationsWhat does this do?

int result = ((((6 + 5) * 4) + 3) * 2);

As opposed to this?

int result = 6 + 5 * 4 + 3 * 2;

Or this?

int result = 6 + (5 * (4 + (3 * 2)));


Order of OperationsWhat does this do?

int result = 7 / 4; //???

What does this do?

int result = 5 % 3; //???

The modulo operator tells you the remainder. So for example 11 / 3 = 3, and 11 % 3 = 2 because the division of 11 by 3 has a remainder of 2.

If you want to represent decimals you use the double data type for your variables.


Increment and decrement operatorJust for fun, there’s another operator which doesn’t work on numbers themselves, but that works instead on variables that contain numbers:

int value = 5;

value++; //increments the number in value by 1

value--; //decrements the number in value by 1

Another common thing to do is to use a variable in a particular operation and then assign the result back into the variable:

int value = 5;

value = value + 5; //now value = 10

You can also write this second line as:

value += 5; //adds 5 to whatever number was in value


Increment operatorremember what happens here?

int myNumber1 = 2,147,483,648; //Error!

but...

int myNumber2 = 2,147,483,647; //upper bound of int

myNumber2++; //???


A bit more about the String objectWe talked about Strings briefly when we mentioned that Java has some built in non-primitive data types. We also make use of Strings whenever we use the System.out.println command. The println instruction (or method) requires that you pass in a String.

You can create this String explicitly:String text = new String(“Hello World!”);Or explicitly, but using a short cut:String text = “Text created with a short cut...”;Or implicitly, on the fly as we invoke the method:System.out.println(“Text created on the fly!”);

Just as we can use a number without assigning it to a variable, we can use a String without assigning it as well. Whenever Java sees a quote, it assumes a String will follow.


The + operator for the String objectThe plus sign for data type String means “append” instead of “add”.

So when you see code that looks like this:

String text1 = “The word String refers to ”;

String text2 = “a ‘string’ of letters...”;

String text3 = text1 + text2;

System.out.println(text3);

So now this is what gets printed on the command line:

The word String refers to a ‘string’ of letters...


The + operator for the String objectThe append operator is smart enough to turn primitive data types into text as well.

int numMonkeys = 99;

System.out.println(“There are ” + numMonkeys + “ monkeys jumping on the bed.”);

prints the following on the command window:

There are 99 monkeys jumping on the bed.


The if statementThere is an important set of syntax in Java referred to as “Control Statements”. They tell the program to ignore or repeat certain parts of the code. The if statement is kind of a bump in the rode. If you hit the bump you go up in the air, and then come back to the ground. If you don’t hit the bump, you just stay on the road.

boolean isBumpInRoad = true;if (isBumpInRoad == true){ System.out.println(“Wheeee!”);}

System.out.println(“on the road...”);

If the boolean variable isBumpInRoad is false, then we never say “Wheeee!”.


equals & equals equals??If there is a single equals, it is the assignment operator. We have been using it since last class for when we put data into a variable.

In this line we are making a bucket of type boolean and putting the value true into it:

boolean isBumpInRoad = true;

But in this line we are checking to see if our variable named isBumpInRoad contains the value true. In other words: is the data in isBumpInRoad equal to the boolean data true? The == operator is the equality operator:

if (isBumpInRoad == true)


equals equalsJust to be slightly more confusing...

If the statement after the if keyword evaluates to true, then we execute the code between the squiggly brackets. Otherwise, we skip them.

boolean isBumpInRoad = true;if (isBumpInRoad == true) //yes this statement is true{

//so yes execute this code!!!}

However, if isBumpInRoad is false, then we skip that code:

boolean isBumpInRoad = false;if (isBumpInRoad == true) //no! this statement is NOT true{

//so we do NOT execute this code!!!}


One more time...If there is a single equals, it is the assignment operator:

int number = 5;

If there is double equals, it is the equality operator:

if (number == 5) //yes this is true

{

System.out.println(“your number is indeed equal to 5.”);

}

But, if we set number to be something else:

int number = 6;

if (number == 5) //no, this is NOT true, so skip...

{

System.out.println(“your number is indeed equal to 5.”);

}


The conditionalThe section inside the parentheses after the if keyword is called the conditional. We evaluate the conditional and if it is true, then we execute the code inside the squiggly brackets. If it is false, then we skip it.

Look at these code snippets and evaluate the conditional:

int number = 15;if (number == 15) {};

char letter = ‘A’;if (letter == ‘A’) {};

if (true) {};

if (false) {};


Other comparison operators(Important note! These comparison operators only work with primitive data types!!! We will explore this later...)

There are also other operators that are used to compare pieces of data.

The “not equals” operator, or inequality operator.

int number = 97;

if (number != 15) {}; //what does this evaluate to?

int number = 97;

if (number != 97) {}; //and this?


Other comparison operatorsThe relational operators (greater than, less than, greater than or equal to, less than or equal to)

int number1 = 97;

int number2 = 98;

if (number1 > number2) {}; //evaluates to?

int number = 5;

if (number <= 5) {}; //and this?

int number = 17;

if (16 >= number) {}; //and this?


For Next WeekYou have some real homework... Let’s look at it...

We will start thinking about larger programs which are made of more than one file.

We will start making (simple) custom objects with custom sets of instructions.

We will learn about all of the control statements available to us.

We will look at the logical operators.

In two weeks... We will start doing some simple 2D graphics

cs 5ja introduction to java last class... we gave a definition of high-level vs. low-level. we...

Documents

integer variable

integer bucket

int mynumber mynumber

variable assignment

bucket of type integer

fragile bucket

ja introduction

mynumber of type int