Docsity
Docsity
Prepare for your exams
Prepare for your exams

Study with the several resources on Docsity

Earn points to download
Earn points to download

Earn points by helping other students or get them with a premium plan

Guidelines and tips
Guidelines and tips
Sell on Docsity
Sell on Docsity
Docsity AI
Docsity AI
Log inSign up

Prepare for your exams

Study with the several resources on Docsity

Find documents

Prepare for your exams with the study notes shared by other students like you on Docsity

Search for your university

Find the specific documents for your university's exams

Docsity AINEW

Summarize your documents, ask them questions, convert them into quizzes and concept maps

Explore questions

Clear up your doubts by reading the answers to questions asked by your fellow students

Earn points to download

Earn points by helping other students or get them with a premium plan

Share documents
download point icon20 Points

For each uploaded document

Answer questions
download point icon5 Points

For each given answer (max 1 per day)

All the ways to get free points
Get points immediately

Choose a premium plan with all the points you need

Study Opportunities

Choose your next study program

Get in touch with the best universities in the world. Search through thousands of universities and official partners

Community

Ask the community

Ask the community for help and clear up your study doubts

Free resources

Our save-the-student-ebooks!

Download our free guides on studying techniques, anxiety management strategies, and thesis advice from Docsity tutors

Basic Control Structures - Lecture Notes | CSC 2310, Exams of Computer Science

Georgia State University (GSU)Computer Science

Material Type: Exam; Class: PRIN OF COMPUTER PROGRAMMING; Subject: COMPUTER SCIENCE; University: Georgia State University; Term: Unknown 1989;

Typology: Exams

Pre 2010

Uploaded on 08/31/2009

koofers-user-nbs
koofers-user-nbs 🇺🇸

4

(2)

10 documents

1 / 5

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Chapter 4: Basic Control Structures.
The basic control structures enable us to accomplish much more than the sequential
statements we have used so far. It lets us test conditions and depending upon the result,
do one thing or the other (if we use the if control structure). When we use the looping
structures, we are able to do one thing many times.
The IF statement:
To use the if statement to carry out tests, we need to use the relational operators:
1. < Less than.
2. > Greater than.
3. <= Less than or equal to.
4. >= Greater then or equal to.
5. == Equal to.
6. != Not Equal to.
These operators apply to numbers (both integer and double). If two numbers are tested,
one of which is an integer and the other is double, the integer will be converted to double
and then tested.
Note: We cannot use the relational operators (<, <=, > & >=) to test objects. We could
however, use the equality operators(== & !=) to compare objects. But this may not give
us the results that we may be seeking because these operators only compare the value
stored in the objects (that is, the address in them) and not the actual contents of the
objects. Thus we would not use these to test strings. We use instead the method equals()
used in the following manner.
object1.equals(object2)
In the expression above, we are testing to see if object1 is equal to object2.
We can also use the equalsIgnoreCase() to compare two strings. This will compare the
two strings ignoring the case of the characters, example:
object1.equalsIgnoreCase(object2)
To test if one string is less than, equal to or greater than another, we will use the
compareTo() method that is available in the library. This method returns integer values –
for example:
1. if (string1 < string2) return value < 0 (maybe –1)
2. if (string1 == string2) return value 0
3. if (string1 > string2) return value > 0 (maybe 1)
How to use this method:
string1.compareTo(string2);
The compareTo() method will go through each character of both strings and compare
them. It will then return a value.The Unicode values are used to determine if one
character is less than another. Note: Upper case A is smaller than Lower case a, thus if
1
pf3
pf4
pf5

Partial preview of the text

Download Basic Control Structures - Lecture Notes | CSC 2310 and more Exams Computer Science in PDF only on Docsity!

Chapter 4: Basic Control Structures. The basic control structures enable us to accomplish much more than the sequential statements we have used so far. It lets us test conditions and depending upon the result, do one thing or the other (if we use the if control structure). When we use the looping structures, we are able to do one thing many times. The IF statement: To use the if statement to carry out tests, we need to use the relational operators:

  1. <  Less than.

  2.  Greater than.

  3. <=  Less than or equal to.

  4. =  Greater then or equal to.

  5. ==  Equal to.
  6. !=  Not Equal to. These operators apply to numbers (both integer and double). If two numbers are tested, one of which is an integer and the other is double, the integer will be converted to double and then tested. Note: We cannot use the relational operators (<, <=, > & >=) to test objects. We could however, use the equality operators(== & !=) to compare objects. But this may not give us the results that we may be seeking because these operators only compare the value stored in the objects (that is, the address in them) and not the actual contents of the objects. Thus we would not use these to test strings. We use instead the method equals() used in the following manner. object1.equals(object2) In the expression above, we are testing to see if object1 is equal to object2. We can also use the equalsIgnoreCase() to compare two strings. This will compare the two strings ignoring the case of the characters, example: object1.equalsIgnoreCase(object2) To test if one string is less than, equal to or greater than another, we will use the compareTo() method that is available in the library. This method returns integer values – for example:
  7. if (string1 < string2)  return value  < 0 (maybe –1)
  8. if (string1 == string2)  return value  0
  9. if (string1 > string2)  return value  > 0 (maybe 1) How to use this method: string1.compareTo(string2); The compareTo() method will go through each character of both strings and compare them. It will then return a value.The Unicode values are used to determine if one character is less than another. Note: Upper case A is smaller than Lower case a, thus if

these were tested (if string1.compareTo(string2): with string1 consisting the value A and string2, the value a) then a value less zero would have been returned. If statements: The if statement allows us to test a condition and decide upon an action depending on the outcome of the test. The structure of the if statement is: if (expression) statement The expression must produce a boolean type because an if statement is geared to always return a true of false answer. The brackets around the expression are mandatory. The evaluation of the if statement is as follows: The expression (in the form of a condition) is evaluated and if it is true, then whatever statements follow the if would be executed. If it is false, nothing would happen (in the above example). Indentation makes if statement more clear and easier to understand, especially when numerous nested if’s are involved. Note: if we write  if (x > y); a = 25; this is incorrect. There should not be a semicolon after the second brace. The compiler will compile this correctly, but depending upon the situation, it could produce error in output. Fortunately, in this case we will get the result we are looking for providing that x is greater than y. This if statement is considered an empty statement and practically does nothing. Blocks: After the test condition, you may want to have more than one statement in the statement area. To do so, they must be placed inside a block. Thus open with the curly brace and close with a curly brace. In side you place any amount of statements with each ending with a semicolon. After the last curly brace, there must be no semicolon. The else statement : When we test with the if statement, we had only one area for action – and that was if the condition tested was true. If the condition tested is false, we may want to do something else thus we use the else statement. The structure is as follows: If (expression) { statement; statement; } else { statement; statement; }

The Dangling else: If we have the following code which should mean that the else should be attached to the first if statement: if (a < b) if (a > c) total = total + a; else total = total + b; The else statement could be misinterpreted to belong to the second if when it was intended for th first if. In fact the compiler will associate it with the second if (the association is made with the first if up the ladder). For this to be corrected, we need to put the second if in a block, example: if (a < b) { if (a > c) total = total + a; } else total = total + b; Loops: Most often than not, we need our algorithm to do something over and over until a condition is met. To do so we use loops. There are two main types of loop available – the while loop and the for loop. For either loop, we must always make sure that the loop will terminate at some point in time, else it would be executing forever. While loop: The while loop is split into two parts (or two format):

  1. When the while statement is placed at the beginning of the loop.
  2. When the do statement is placed at the beginning of the loop. In the first case, because the condition is tested before entering the loop, the loop may not be executed at all. Example, if we are reading data from a file using a while loop, we could have the following syntax: while(x > y) //test to see if x is greater than y. { //if it is, then go into the loop. a = b * c; ……… } So a while loop would test the condition – if it is true, then execute the loop.

In the use of the do, we have: do { a = b * c; ……… } } while(x > y); Using the while loop for counting: We do not want an infinite loop, as the following: while (true) { int i = 0, j = 0; System.out.println(i++); System.out.println(++j); } Generally, when ++ and -- operators are used in expressions, they cause the value of the attached variable to either increase by 1 or decrease by 1. These could be placed either before the variable or after the variable as in the above example. In the above case, when placed after the variable, the value for the variable would be printed then increased. When placed before the value of the variable would be increased, then printed. So in the first case, the output would start from 0, whereas in the later case, it would start from 1. However, this happens only as in this case, when they are put inside a print statement. If they are used inside a program other wise, it does not matter where they are place. Same is true for the – operator. Also note that the above code would produce an infinite loop. We could add a break statement to get out of the loop – as follows. while (true) { int i = 0, j = 0; System.out.println(i++); System.out.println(++j); if(I == 50) || (j == 50) break; }