* Chapter 1:
Programming, and Java

* A programming language is defined by: * Syntax: grammar to specify how the instructions are written * Semantics: what does the instructions mean

* Languages are divided into three categories: * High-Level language * Assembly language * Machine language

* Part 1: Fundamental Programming Concepts * Primitive data types and operations * Control Statements (Selection and Loops) * Methods * Arrays * Part 2: Object-Oriented Programming * Encapsulation * Inheritance * Polymorphism

Anatomy of a Java Program * class header * main method * Statements * Comments

* In order for a Java program to be executed, the class MUST have a method called main() * The body of any function must be contained in braces { } * Java is case sensitive * Main is not the same as main

* Each Java program has two different types of files: * Source code file (filename.java): * The file in which you declare your class and write your algorithm * Each .java file declares only one class * The file name should be the exact same name as the class name (case sensitive) * Executable file (filename.class): * Automatically generated * Has exact same name as the corresponding .java file but with a different extension * Not human readable

Programming Errors * Syntax Errors * Detected by the compiler * Runtime Errors * Causes the program to abort * Logic Errors * Produces incorrect result

* A variable is declared by: * Variable’s Data Type: (e.g., integer, string) * Variable’s Name: (e.g., sum, price)
Primitive Data Types in Java * byte * 8-bits signed integer * int * 32-bits integer * float * A number with a decimal point: 10.5 or 45.55 * 32-bits * double * A very large number with a decimal point: 123456789.56743 * 64-bits * short * 16-bits signed integer * long * 64-bits signed integer * -9,223,372,036,854,775,808 to +9,223,372,036,854,775,807 * char * One character: ‘A’, ‘B’, ‘X’, or ’*’ * 16-bits * boolean * True or False * Scanner is an object that is used to input a value from the keyboard * Before using any object you need to import the corresponding library import java.util.Scanner; * Remember that the library System.out is included by default in any Java class
Write a program that reads a one-digit number from the user then prints on the screen the digit in letters. For example

int digit; System.out.println(“Enter a single digit number:“); digit = input.nextInt(); if (digit == 0) System.out.println(“ ZERO “); else if (digit==1) System.out.println(“ ONE “); else if (digit==2) System.out.println(“ TWO “); …and so on….. else System.out.println(“ Not a single-digit number“);
Rewriting Example using switch-case

int digit;
System.out.println(“Enter a single digit number”); digit = input.nextInt(); switch(digit) { case 0: System.out.println(“ZERO"); break; case 1: System.out.println(“ONE“); break; case 2: System.out.println(“TWO"); break; …and so on ….. default: System.out.println(“Not a single digit number”); }

int grade;
System.out.println(“Enter a number”); grade = input.nextInt(); switch(grade/10){ case 9: case 10: System.out.println(“A”); break; case 8: System.out.println(“B”); break; case 7: System.out.println(“C”); break; case 6: System.out.println(“D”); break; default: System.out.println(“F”); break; }

• The loop condition is evaluated before the first execution of the loop body:
• The loop body may not be executed at all if the condition is initially evaluated to false
• If the condition evaluates to true, the loop body is executed
• The loop condition is rechecked after each execution of the loop body
• The statement(s) in the loop’s body are re-executed as long as the loop condition is true.
• As soon as the condition evaluates to false, the loop terminates. * There are three structures to express loops in JavaL * The while structure * The do..while structure * The for structure • while structure:
• Checks the condition before the first execution of the loop body.
• The loop body is not executed if the condition is initially FALSE.
• The loop body is executed zero or more times.
• do..while structure:
• Checks the condition after the first execution of the loop body.
• The loop body is executed one or more times.
• We guarantee that the body is executed at least once.
• Write a program that uses a while loop to read the exam grade for a class of 10 students. Your program then calculates and displays the average grade
• int counter = 0;
• int grade;
• int total = 0;
• double average ;
• while ( counter < 10 ){
• System.out.println(“Grade for Student# “ +counter) ;
• grade = input.nextInt() ;
• total = total + grade ;
• counter = counter + 1 ;
• }
• average = (double) total / 10 ;
• System.out.println(“Class average is: “+ average) ;
• If a loop does not contain within itself a way to terminate, it is called An infinite loop
A loop that executes as long as a particular condition exists is called a(n )Conditional loop
A loop that repeats a specific number of times is known as a(n) Count-controlled loop
== The equality relational operator.
< The less than relational operator.
<= The less than or equal relational operator.
> The greater than relational operator.
>= The greater than or equal relational operator.
!= The not equal relational operator.
&& The logical And operator.
|| The logical Or operator.
! The logical Not operator. break A statement that moves program control to the next statement after the current structure. case A clause in the switch statement that contains statements to be executed when the case condition matches the result of the switch expression. if A decision structure that executes a set of statements when a condition is true. if-else A decision structure that executes one set of statements when a condition is true and another set of statements when the condition is false. if-else if A decision structure used to decide among three or more actions.
Math A java.lang class with methods for generating random numbers and performing math functions. switch A decision structure that uses the result of an expression to determine which set of statements to execute.
• Loop
• A group of instructions that a computer executes repeatedly while some condition remains TRUE
• Counter-controlled repetition
• Definite repetition: you know how many times the loop will execute
• A control variable is used to count the repetitions
• Sentinel-controlled repetition
• Indefinite repetition
• Used when the number of repetitions is not known
Sentinel value indicates "end-of-data * Two types of conversions: * Widening conversion: * Convert from one type to another type with larger number of bits * From int to double * Narrowing conversion: * Converting from a data type to a smaller type * From double to int * Some information may be lost * Increment (++): * Adds 1 to its operand * Prefix increment: ++a * Postfix increment: a++ * ++a; is the same as a++; is the same as a = a+1; * Decrement (--): * Subtracts 1 from its operand * Prefix decrement: --a; * Postfix decrement: a- -;
--a; is the same as a--; is the same as a = a- * The postfix and prefix are different only when they are used in an assignment statement * x = a++; is not the same as x = ++a; * x = ++a increments a before its value is assigned to x * x = a++ increments a after its value is assigned to x

Generating Random Numbers * Math.random() is used to generate a random double value between 0.0 and 1.0 excluding 1.0 * To generate an integer between 0 and 9 int num = (int) (Math.random() * 10) * To generate an integer between 0 and 100 int num = (int) (Math.random
Random Question * Given the following declaration, how would you get:
Random rand = new Random(); * A random number between 1 and 100 inclusive? int random1 = rand.nextInt(100) + 1; * A random number between 50 and 100 inclusive? int random2 = rand.nextInt(51) + 50; * A random number between 4 and 17 inclusive? int random3 = rand.nextInt(14) + 4;

* Logical Operators are used to create compound conditions * Three are three logical operators: * || ( logical OR ) * A binary expression formed with || evaluates to 1 (true) if any one of its components is true * && ( logical AND ) * A binary expression formed with && evaluates to true if all of its components are true * ! ( logical NOT, logical negation ) * The unary negation operator ! converts a non-zero operand into 0, and a zero operand in 1. * while loop’s body MUST have a statement that eventually causes the condition to become FALSE * Infinite loop will take place if you don’t provide the loop body with such a statement * Example: int counter = 1; while ( counter <= 10 ) System.out.println( counter ); * This loop will never terminate because counter will never be > 10 because there is no statement to increment counter * This loop will never terminate because counter will never be > 10 because there is no statement to increment counter * Write a program that uses a while loop to read the exam grade for a class of 10 students. Your program then calculates and displays the average grade * Inputs? * exam grades * How many grades? * 10 * outputs? * the average exam grade * int counter = 0; * int grade; * int total = 0; * double average ; * while ( counter < 10 ){ * System.out.println(“Grade for Student# “ +counter) ; * grade = input.nextInt() ; * total = total + grade ; * counter = counter + 1 ; * } * average = (double) total / 10 ; * System.out.println(“Class average is: “+ average) ; * * * Write a program to print the even numbers that are less than 20 * Initialize loop index: * int counter = 2 * Loop continuation test: * counter <= 20 * Step: * Only even numbers are needed, then the step is 2 * counter = counter + 2 for (int counter = 2; counter <= 20; counter=counter+2){ System.out.println( counter );
}
Write a program to find the sum of even numbers less than 100 int sum = 0; //initialize sum for (int number = 2; number <=100 ; number = number +2){ sum = sum + number; } System.out.println(“The sum is ”+ sum); * Write a statement to print the integers from 100 down to 0 (i.e., descending order) for (int counter = 100; counter >= 0; counter = counter - 1){ System.out.println( counter );
}
* Write a for loop to print the following sequence: 100, 90, 80, 70, 60, 50, 40, 30, 20, 10, 0 for (int seqnum = 100; seqnum >= 0; seqnum = seqnum - 10){ System.out.println( seqnum );
}
* * Find the sum of integers from 1 to 10, from 20 to 30, and from 35 to 45, respectively. int sum = 0; for (int i = 1; i <= 10; i++) sum += i;
System.out.println("Sum from 1 to 10 is " + sum); sum = 0; for (int i = 20; i <= 30; i++) sum += i;
System.out.println("Sum from 20 to 30 is " + sum); sum = 0; for (int i = 35; i <= 45; i++) sum += i;
System.out.println("Sum from 35 to 45 is " + sum);

How to use Java API? * Import library import java.util.* * Create an Object Scanner input = new Scanner(System.in); * Method call: int num = input.nextInt() * Math Class

* Class constants: * PI * E * Class methods: * Trigonometric Methods * Exponent Methods * Rounding Methods * min, max, abs, and random Methods
Scanner Class * Sample methods: * next() * nextLine() * nextInt() * nextDouble(); * nextLong() * String Class * Sample methods: * charAt(index) * indexOf(ch) * length() * replace(a,b)
Method Declaration * Method name: * Programmer chooses the method name * Should be selected to indicate the method’s objective * Data type of output: * Specifies the data type of the function’s output * A function can have zero or one output * If zero output: return_value_type is void * If onr output: return_value_type is int, char, double, or float * Input parameters: * A function can have zero or more inputs * A date type must be listed explicitly for each input